Rename functions, fields and adjust comments to use `fragment` instead of `box`

I tried to make sure to keep 'box' where it made sense, and alter comments so they still make sense.

15 files changed, 847 insertions, 849 deletions

diff --git a/src/components/main/layout/block.rs b/src/components/main/layout/block.rs
index a69f839d8e9..b4fe5790e9c 100644
--- a/src/components/main/layout/block.rs
+++ b/src/components/main/layout/block.rs
@@ -52,7 +52,7 @@ pub struct FloatedBlockInfo {
     /// Offset relative to where the parent tried to position this flow
     pub rel_pos: Point2D<Au>,
 
-    /// Index into the box list for inline floats
+    /// Index into the fragment list for inline floats
     pub index: Option<uint>,
 
     /// Left or right?
@@ -488,8 +488,8 @@ pub struct BlockFlow {
     /// Data common to all flows.
     pub base: BaseFlow,
 
-    /// The associated box.
-    pub box_: Fragment,
+    /// The associated fragment.
+    pub fragment: Fragment,
 
     /// TODO: is_root should be a bit field to conserve memory.
     /// Whether this block flow is the root flow.
@@ -510,7 +510,7 @@ impl BlockFlow {
     pub fn from_node(constructor: &mut FlowConstructor, node: &ThreadSafeLayoutNode) -> BlockFlow {
         BlockFlow {
             base: BaseFlow::new((*node).clone()),
-            box_: Fragment::new(constructor, node),
+            fragment: Fragment::new(constructor, node),
             is_root: false,
             static_y_offset: Au::new(0),
             previous_float_width: None,
@@ -518,10 +518,10 @@ impl BlockFlow {
         }
     }
 
-    pub fn from_node_and_box(node: &ThreadSafeLayoutNode, box_: Fragment) -> BlockFlow {
+    pub fn from_node_and_fragment(node: &ThreadSafeLayoutNode, fragment: Fragment) -> BlockFlow {
         BlockFlow {
             base: BaseFlow::new((*node).clone()),
-            box_: box_,
+            fragment: fragment,
             is_root: false,
             static_y_offset: Au::new(0),
             previous_float_width: None,
@@ -535,7 +535,7 @@ impl BlockFlow {
                            -> BlockFlow {
         BlockFlow {
             base: BaseFlow::new((*node).clone()),
-            box_: Fragment::new(constructor, node),
+            fragment: Fragment::new(constructor, node),
             is_root: false,
             static_y_offset: Au::new(0),
             previous_float_width: None,
@@ -600,9 +600,9 @@ impl BlockFlow {
         }
     }
 
-    /// Return this flow's box.
-    pub fn box_<'a>(&'a mut self) -> &'a mut Fragment {
-        &mut self.box_
+    /// Return this flow's fragment.
+    pub fn fragment<'a>(&'a mut self) -> &'a mut Fragment {
+        &mut self.fragment
     }
 
     /// Return the static x offset from the appropriate Containing Block for this flow.
@@ -698,12 +698,12 @@ impl BlockFlow {
         traversal.process(flow)
     }
 
-    /// Return true if this has a replaced box.
+    /// Return true if this has a replaced fragment.
     ///
-    /// The only two types of replaced boxes currently are text boxes and
-    /// image boxes.
+    /// The only two types of replaced fragments currently are text fragments
+    /// and image fragments.
     fn is_replaced_content(&self) -> bool {
-        match self.box_.specific {
+        match self.fragment.specific {
             ScannedTextFragment(_) | ImageFragment(_) => true,
             _ => false,
         }
@@ -765,7 +765,7 @@ impl BlockFlow {
     ///
     /// TODO(#2017, pcwalton): This is somewhat inefficient (traverses kids twice); can we do
     /// better?
-    fn adjust_boxes_for_collapsed_margins_if_root(&mut self) {
+    fn adjust_fragments_for_collapsed_margins_if_root(&mut self) {
         if !self.is_root() {
             return
         }
@@ -788,7 +788,7 @@ impl BlockFlow {
 
         self.base.position.size.height = self.base.position.size.height + top_margin_value +
             bottom_margin_value;
-        self.box_.border_box.size.height = self.box_.border_box.size.height + top_margin_value +
+        self.fragment.border_box.size.height = self.fragment.border_box.size.height + top_margin_value +
             bottom_margin_value;
     }
 
@@ -822,17 +822,17 @@ impl BlockFlow {
         }
 
         let mut margin_collapse_info = MarginCollapseInfo::new();
-        self.base.floats.translate(Point2D(-self.box_.left_offset(), Au(0)));
+        self.base.floats.translate(Point2D(-self.fragment.left_offset(), Au(0)));
 
         // The sum of our top border and top padding.
-        let top_offset = self.box_.border_padding.top;
+        let top_offset = self.fragment.border_padding.top;
         translate_including_floats(&mut cur_y, top_offset, &mut self.base.floats);
 
         let can_collapse_top_margin_with_kids =
             margins_may_collapse == MarginsMayCollapse &&
             !self.is_absolutely_positioned() &&
-            self.box_.border_padding.top == Au(0);
-        margin_collapse_info.initialize_top_margin(&self.box_,
+            self.fragment.border_padding.top == Au(0);
+        margin_collapse_info.initialize_top_margin(&self.fragment,
                                                    can_collapse_top_margin_with_kids);
 
         // At this point, `cur_y` is at the content edge of our box. Now iterate over children.
@@ -934,10 +934,10 @@ impl BlockFlow {
         let can_collapse_bottom_margin_with_kids =
             margins_may_collapse == MarginsMayCollapse &&
             !self.is_absolutely_positioned() &&
-            self.box_.border_padding.bottom == Au(0);
+            self.fragment.border_padding.bottom == Au(0);
         let (collapsible_margins, delta) =
             margin_collapse_info.finish_and_compute_collapsible_margins(
-            &self.box_,
+            &self.fragment,
             can_collapse_bottom_margin_with_kids);
         self.base.collapsible_margins = collapsible_margins;
         translate_including_floats(&mut cur_y, delta, &mut floats);
@@ -963,11 +963,11 @@ impl BlockFlow {
 
             // Store the content height for use in calculating the absolute flow's dimensions
             // later.
-            self.box_.border_box.size.height = height;
+            self.fragment.border_box.size.height = height;
             return
         }
 
-        let mut candidate_height_iterator = CandidateHeightIterator::new(self.box_.style(),
+        let mut candidate_height_iterator = CandidateHeightIterator::new(self.fragment.style(),
                                                                          None);
         for (candidate_height, new_candidate_height) in candidate_height_iterator {
             *new_candidate_height = match candidate_height {
@@ -982,17 +982,17 @@ impl BlockFlow {
         translate_including_floats(&mut cur_y, delta, &mut floats);
 
         // Compute content height and noncontent height.
-        let bottom_offset = self.box_.border_padding.bottom;
+        let bottom_offset = self.fragment.border_padding.bottom;
         translate_including_floats(&mut cur_y, bottom_offset, &mut floats);
 
         // Now that `cur_y` is at the bottom of the border box, compute the final border box
         // position.
-        self.box_.border_box.size.height = cur_y;
-        self.box_.border_box.origin.y = Au(0);
+        self.fragment.border_box.size.height = cur_y;
+        self.fragment.border_box.origin.y = Au(0);
         self.base.position.size.height = cur_y;
 
         self.base.floats = floats.clone();
-        self.adjust_boxes_for_collapsed_margins_if_root();
+        self.adjust_fragments_for_collapsed_margins_if_root();
 
         if self.is_root_of_absolute_flow_tree() {
             // Assign heights for all flows in this Absolute flow tree.
@@ -1018,16 +1018,16 @@ impl BlockFlow {
     /// already called on this kid flow by the traversal function. So, the values used are
     /// well-defined.
     pub fn place_float(&mut self) {
-        let height = self.box_.border_box.size.height;
-        let clearance = match self.box_.clear() {
+        let height = self.fragment.border_box.size.height;
+        let clearance = match self.fragment.clear() {
             None => Au(0),
             Some(clear) => self.base.floats.clearance(clear),
         };
 
-        let margin_height = self.box_.margin.vertical();
+        let margin_height = self.fragment.margin.vertical();
         let info = PlacementInfo {
-            size: Size2D(self.base.position.size.width + self.box_.margin.horizontal() +
-                         self.box_.border_padding.horizontal(),
+            size: Size2D(self.base.position.size.width + self.fragment.margin.horizontal() +
+                         self.fragment.border_padding.horizontal(),
                          height + margin_height),
             ceiling: clearance + self.base.position.origin.y,
             max_width: self.float.get_ref().containing_width,
@@ -1060,7 +1060,7 @@ impl BlockFlow {
         // Floats establish a block formatting context, so we discard the output floats here.
         drop(floats);
 
-        let top_offset = self.box_.margin.top + self.box_.border_padding.top;
+        let top_offset = self.fragment.margin.top + self.fragment.border_padding.top;
         let mut cur_y = top_offset;
 
         // cur_y is now at the top content edge
@@ -1074,11 +1074,11 @@ impl BlockFlow {
 
         let content_height = cur_y - top_offset;
 
-        // The associated box is the border box of this flow.
-        self.box_.border_box.origin.y = self.box_.margin.top;
+        // The associated fragment has the border box of this flow.
+        self.fragment.border_box.origin.y = self.fragment.margin.top;
 
         // Calculate content height, taking `min-height` and `max-height` into account.
-        let mut candidate_height_iterator = CandidateHeightIterator::new(self.box_.style(), None);
+        let mut candidate_height_iterator = CandidateHeightIterator::new(self.fragment.style(), None);
         for (candidate_height, new_candidate_height) in candidate_height_iterator {
             *new_candidate_height = match candidate_height {
                 Auto => content_height,
@@ -1087,9 +1087,9 @@ impl BlockFlow {
         }
 
         let content_height = candidate_height_iterator.candidate_value;
-        let noncontent_height = self.box_.border_padding.vertical();
+        let noncontent_height = self.fragment.border_padding.vertical();
         debug!("assign_height_float -- height: {}", content_height + noncontent_height);
-        self.box_.border_box.size.height = content_height + noncontent_height;
+        self.fragment.border_box.size.height = content_height + noncontent_height;
     }
 
     fn build_display_list_block_common(&mut self,
@@ -1097,7 +1097,7 @@ impl BlockFlow {
                                        offset: Point2D<Au>,
                                        background_border_level: BackgroundAndBorderLevel) {
         let rel_offset =
-            self.box_.relative_position(&self.base
+            self.fragment.relative_position(&self.base
                                              .absolute_position_info
                                              .relative_containing_block_size,
                                         None);
@@ -1105,11 +1105,11 @@ impl BlockFlow {
         // Add the box that starts the block context.
         let mut display_list = DisplayList::new();
         let mut accumulator =
-            self.box_.build_display_list(&mut display_list,
-                                         layout_context,
-                                         self.base.abs_position + rel_offset + offset,
-                                         background_border_level,
-                                         None);
+            self.fragment.build_display_list(&mut display_list,
+                                             layout_context,
+                                             self.base.abs_position + rel_offset + offset,
+                                             background_border_level,
+                                             None);
 
         let mut child_layers = DList::new();
         for kid in self.base.child_iter() {
@@ -1176,39 +1176,39 @@ impl BlockFlow {
         let static_y_offset = self.static_y_offset;
 
         // This is the stored content height value from assign-height
-        let content_height = self.box_.content_box().size.height;
+        let content_height = self.fragment.content_box().size.height;
 
         let mut solution = None;
         {
             // Non-auto margin-top and margin-bottom values have already been
             // calculated during assign-width.
-            let margin_top = match self.box_.style().get_margin().margin_top {
+            let margin_top = match self.fragment.style().get_margin().margin_top {
                 LPA_Auto => Auto,
-                _ => Specified(self.box_.margin.top)
+                _ => Specified(self.fragment.margin.top)
             };
-            let margin_bottom = match self.box_.style().get_margin().margin_bottom {
+            let margin_bottom = match self.fragment.style().get_margin().margin_bottom {
                 LPA_Auto => Auto,
-                _ => Specified(self.box_.margin.bottom)
+                _ => Specified(self.fragment.margin.bottom)
             };
 
             let top;
             let bottom;
             {
-                let position_style = self.box_.style().get_positionoffsets();
+                let position_style = self.fragment.style().get_positionoffsets();
                 top = MaybeAuto::from_style(position_style.top, containing_block_height);
                 bottom = MaybeAuto::from_style(position_style.bottom, containing_block_height);
             }
 
-            let available_height = containing_block_height - self.box_.border_padding.vertical();
+            let available_height = containing_block_height - self.fragment.border_padding.vertical();
             if self.is_replaced_content() {
                 // Calculate used value of height just like we do for inline replaced elements.
                 // TODO: Pass in the containing block height when Fragment's
                 // assign-height can handle it correctly.
-                self.box_.assign_replaced_height_if_necessary();
+                self.fragment.assign_replaced_height_if_necessary();
                 // TODO: Right now, this content height value includes the
-                // margin because of erroneous height calculation in box_.
+                // margin because of erroneous height calculation in fragment.
                 // Check this when that has been fixed.
-                let height_used_val = self.box_.border_box.size.height;
+                let height_used_val = self.fragment.border_box.size.height;
                 solution = Some(HeightConstraintSolution::solve_vertical_constraints_abs_replaced(
                         height_used_val,
                         margin_top,
@@ -1219,7 +1219,7 @@ impl BlockFlow {
                         available_height,
                         static_y_offset));
             } else {
-                let style = self.box_.style();
+                let style = self.fragment.style();
                 let mut candidate_height_iterator =
                     CandidateHeightIterator::new(style, Some(containing_block_height));
 
@@ -1241,13 +1241,13 @@ impl BlockFlow {
         }
 
         let solution = solution.unwrap();
-        self.box_.margin.top = solution.margin_top;
-        self.box_.margin.bottom = solution.margin_bottom;
-        self.box_.border_box.origin.y = Au(0);
-        self.box_.border_box.size.height = solution.height + self.box_.border_padding.vertical();
+        self.fragment.margin.top = solution.margin_top;
+        self.fragment.margin.bottom = solution.margin_bottom;
+        self.fragment.border_box.origin.y = Au(0);
+        self.fragment.border_box.size.height = solution.height + self.fragment.border_padding.vertical();
 
-        self.base.position.origin.y = solution.top + self.box_.margin.top;
-        self.base.position.size.height = solution.height + self.box_.border_padding.vertical();
+        self.base.position.origin.y = solution.top + self.fragment.margin.top;
+        self.base.position.size.height = solution.height + self.fragment.border_padding.vertical();
     }
 
     /// Add display items for Absolutely Positioned flow.
@@ -1288,7 +1288,7 @@ impl BlockFlow {
         self.base.layers.push_back(new_layer)
     }
 
-    /// Return the top outer edge of the Hypothetical Fragment for an absolute flow.
+    /// Return the top outer edge of the hypothetical box for an absolute flow.
     ///
     /// This is wrt its parent flow box.
     ///
@@ -1316,7 +1316,7 @@ impl BlockFlow {
         let absolute_static_x_offset = if self.is_positioned() {
             // This flow is the containing block. The static X offset will be the left padding
             // edge.
-            self.box_.border_padding.left - model::border_from_style(self.box_.style()).left
+            self.fragment.border_padding.left - model::border_from_style(self.fragment.style()).left
         } else {
             // For kids, the left margin edge will be at our left content edge. The current static
             // offset is at our left margin edge. So move in to the left content edge.
@@ -1395,7 +1395,7 @@ impl BlockFlow {
     /// Determines the type of formatting context this is. See the definition of
     /// `FormattingContextType`.
     fn formatting_context_type(&self) -> FormattingContextType {
-        let style = self.box_.style();
+        let style = self.fragment.style();
         if style.get_box().float != float::none {
             return OtherFormattingContext
         }
@@ -1423,7 +1423,7 @@ impl Flow for BlockFlow {
 
     /// Returns the direction that this flow clears floats in, if any.
     fn float_clearance(&self) -> clear::T {
-        self.box_.style().get_box().clear
+        self.fragment.style().get_box().clear
     }
 
     /// Pass 1 of reflow: computes minimum and preferred widths.
@@ -1431,7 +1431,7 @@ impl Flow for BlockFlow {
     /// Recursively (bottom-up) determine the flow's minimum and preferred widths. When called on
     /// this flow, all child flows have had their minimum and preferred widths set. This function
     /// must decide minimum/preferred widths based on its children's widths and the dimensions of
-    /// any boxes it is responsible for flowing.
+    /// any fragments it is responsible for flowing.
     ///
     /// TODO(pcwalton): Inline blocks.
     fn bubble_widths(&mut self, _: &mut LayoutContext) {
@@ -1457,15 +1457,15 @@ impl Flow for BlockFlow {
             flags.union_floated_descendants_flags(child_base.flags);
         }
 
-        let box_intrinsic_widths = self.box_.intrinsic_widths(None);
+        let fragment_intrinsic_widths = self.fragment.intrinsic_widths(None);
         intrinsic_widths.minimum_width = geometry::max(intrinsic_widths.minimum_width,
-                                                       box_intrinsic_widths.minimum_width);
+                                                       fragment_intrinsic_widths.minimum_width);
         intrinsic_widths.preferred_width = geometry::max(intrinsic_widths.preferred_width,
-                                                         box_intrinsic_widths.preferred_width);
-        intrinsic_widths.surround_width = box_intrinsic_widths.surround_width;
+                                                         fragment_intrinsic_widths.preferred_width);
+        intrinsic_widths.surround_width = fragment_intrinsic_widths.surround_width;
         self.base.intrinsic_widths = intrinsic_widths;
 
-        match self.box_.style().get_box().float {
+        match self.fragment.style().get_box().float {
             float::none => {}
             float::left => flags.set_has_left_floated_descendants(true),
             float::right => flags.set_has_right_floated_descendants(true),
@@ -1473,10 +1473,10 @@ impl Flow for BlockFlow {
         self.base.flags = flags
     }
 
-    /// Recursively (top-down) determines the actual width of child contexts and boxes. When called
-    /// on this context, the context has had its width set by the parent context.
+    /// Recursively (top-down) determines the actual width of child contexts and fragments. When
+    /// called on this context, the context has had its width set by the parent context.
     ///
-    /// Dual boxes consume some width first, and the remainder is assigned to all child (block)
+    /// Dual fragments consume some width first, and the remainder is assigned to all child (block)
     /// contexts.
     fn assign_widths(&mut self, layout_context: &mut LayoutContext) {
         debug!("assign_widths({}): assigning width for flow",
@@ -1518,8 +1518,8 @@ impl Flow for BlockFlow {
                 match self.previous_float_width {
                     None => {}
                     Some(previous_float_width) => {
-                        self.box_.border_box.size.width =
-                            self.box_.border_box.size.width - previous_float_width
+                        self.fragment.border_box.size.width =
+                            self.fragment.border_box.size.width - previous_float_width
                     }
                 }
             }
@@ -1530,9 +1530,9 @@ impl Flow for BlockFlow {
         }
 
         // Move in from the left border edge
-        let left_content_edge = self.box_.border_box.origin.x + self.box_.border_padding.left;
-        let padding_and_borders = self.box_.border_padding.horizontal();
-        let content_width = self.box_.border_box.size.width - padding_and_borders;
+        let left_content_edge = self.fragment.border_box.origin.x + self.fragment.border_padding.left;
+        let padding_and_borders = self.fragment.border_padding.horizontal();
+        let content_width = self.fragment.border_box.size.width - padding_and_borders;
 
         if self.is_float() {
             self.base.position.size.width = content_width;
@@ -1562,8 +1562,8 @@ impl Flow for BlockFlow {
     }
 
     fn assign_height(&mut self, ctx: &mut LayoutContext) {
-        // Assign height for box if it is an image box.
-        self.box_.assign_replaced_height_if_necessary();
+        // Assign height for fragment if it is an image fragment.
+        self.fragment.assign_replaced_height_if_necessary();
 
         if self.is_float() {
             debug!("assign_height_float: assigning height for float");
@@ -1598,10 +1598,10 @@ impl Flow for BlockFlow {
         // the content box. The containing block for absolutely-positioned descendants, on the
         // other hand, is only established if we are positioned.
         let relative_offset =
-            self.box_.relative_position(&self.base
-                                             .absolute_position_info
-                                             .relative_containing_block_size,
-                                        None);
+            self.fragment.relative_position(&self.base
+                                                 .absolute_position_info
+                                                 .relative_containing_block_size,
+                                            None);
         if self.is_positioned() {
             self.base.absolute_position_info.absolute_containing_block_position =
                 self.base.abs_position +
@@ -1617,7 +1617,7 @@ impl Flow for BlockFlow {
 
         // Compute absolute position info for children.
         let mut absolute_position_info = self.base.absolute_position_info;
-        absolute_position_info.relative_containing_block_size = self.box_.content_box().size;
+        absolute_position_info.relative_containing_block_size = self.fragment.content_box().size;
         absolute_position_info.layers_needed_for_positioned_flows =
             self.base.flags.layers_needed_for_descendants();
 
@@ -1665,7 +1665,7 @@ impl Flow for BlockFlow {
 
     /// The 'position' property of this flow.
     fn positioning(&self) -> position::T {
-        self.box_.style.get_box().position
+        self.fragment.style.get_box().position
     }
 
     /// Return true if this is the root of an Absolute flow tree.
@@ -1678,17 +1678,17 @@ impl Flow for BlockFlow {
     /// Return the dimensions of the containing block generated by this flow for absolutely-
     /// positioned descendants. For block flows, this is the padding box.
     fn generated_containing_block_rect(&self) -> Rect<Au> {
-        let border = model::border_from_style(self.box_.style());
-        Rect(self.box_.border_box.origin + Point2D(border.left, border.top),
-             Size2D(self.box_.border_box.size.width - border.horizontal(),
-                    self.box_.border_box.size.height - border.vertical()))
+        let border = model::border_from_style(self.fragment.style());
+        Rect(self.fragment.border_box.origin + Point2D(border.left, border.top),
+             Size2D(self.fragment.border_box.size.width - border.horizontal(),
+                    self.fragment.border_box.size.height - border.vertical()))
     }
 
     fn layer_id(&self, fragment_index: uint) -> LayerId {
         // FIXME(#2010, pcwalton): This is a hack and is totally bogus in the presence of pseudo-
         // elements. But until we have incremental reflow we can't do better--we recreate the flow
         // for every DOM node so otherwise we nuke layers on every reflow.
-        LayerId(self.box_.node.id(), fragment_index)
+        LayerId(self.fragment.node.id(), fragment_index)
     }
 
     fn is_absolute_containing_block(&self) -> bool {
@@ -1699,11 +1699,11 @@ impl Flow for BlockFlow {
 impl fmt::Show for BlockFlow {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if self.is_float() {
-            write!(f.buf, "FloatFlow: {}", self.box_)
+            write!(f.buf, "FloatFlow: {}", self.fragment)
         } else if self.is_root() {
-            write!(f.buf, "RootFlow: {}", self.box_)
+            write!(f.buf, "RootFlow: {}", self.fragment)
         } else {
-            write!(f.buf, "BlockFlow: {}", self.box_)
+            write!(f.buf, "BlockFlow: {}", self.fragment)
         }
     }
 }
@@ -1793,9 +1793,9 @@ pub trait WidthAndMarginsComputer {
         let containing_block_width = self.containing_block_width(block, parent_flow_width, ctx);
         let computed_width = self.initial_computed_width(block, parent_flow_width, ctx);
 
-        block.box_.compute_border_padding_margins(containing_block_width, None);
+        block.fragment.compute_border_padding_margins(containing_block_width, None);
 
-        let style = block.box_.style();
+        let style = block.fragment.style();
 
         // The text alignment of a block flow is the text alignment of its box's style.
         block.base.flags.set_text_align(style.get_inheritedtext().text_align);
@@ -1807,7 +1807,7 @@ pub trait WidthAndMarginsComputer {
         let (left, right) =
             (MaybeAuto::from_style(style.get_positionoffsets().left, containing_block_width),
              MaybeAuto::from_style(style.get_positionoffsets().right, containing_block_width));
-        let available_width = containing_block_width - block.box_.border_padding.horizontal();
+        let available_width = containing_block_width - block.fragment.border_padding.horizontal();
         return WidthConstraintInput::new(computed_width,
                                          margin_left,
                                          margin_right,
@@ -1828,15 +1828,15 @@ pub trait WidthAndMarginsComputer {
     fn set_width_constraint_solutions(&self,
                                       block: &mut BlockFlow,
                                       solution: WidthConstraintSolution) {
-        let box_ = block.box_();
-        box_.margin.left = solution.margin_left;
-        box_.margin.right = solution.margin_right;
+        let fragment = block.fragment();
+        fragment.margin.left = solution.margin_left;
+        fragment.margin.right = solution.margin_right;
 
-        // The associated box is the border box of this flow.
+        // The associated fragment has the border box of this flow.
         // Left border edge.
-        box_.border_box.origin.x = box_.margin.left;
+        fragment.border_box.origin.x = fragment.margin.left;
         // Border box width.
-        box_.border_box.size.width = solution.width + box_.border_padding.horizontal();
+        fragment.border_box.size.width = solution.width + fragment.border_padding.horizontal();
     }
 
     /// Set the x coordinate of the given flow if it is absolutely positioned.
@@ -1853,7 +1853,7 @@ pub trait WidthAndMarginsComputer {
                               parent_flow_width: Au,
                               ctx: &mut LayoutContext)
                               -> MaybeAuto {
-        MaybeAuto::from_style(block.box_().style().get_box().width,
+        MaybeAuto::from_style(block.fragment().style().get_box().width,
                               self.containing_block_width(block, parent_flow_width, ctx))
     }
 
@@ -1880,7 +1880,7 @@ pub trait WidthAndMarginsComputer {
 
         // If the tentative used width is greater than 'max-width', width should be recalculated,
         // but this time using the computed value of 'max-width' as the computed value for 'width'.
-        match specified_or_none(block.box_().style().get_box().max_width, containing_block_width) {
+        match specified_or_none(block.fragment().style().get_box().max_width, containing_block_width) {
             Some(max_width) if max_width < solution.width => {
                 input.computed_width = Specified(max_width);
                 solution = self.solve_width_constraints(block, &input);
@@ -1890,7 +1890,7 @@ pub trait WidthAndMarginsComputer {
 
         // If the resulting width is smaller than 'min-width', width should be recalculated,
         // but this time using the value of 'min-width' as the computed value for 'width'.
-        let computed_min_width = specified(block.box_().style().get_box().min_width,
+        let computed_min_width = specified(block.fragment().style().get_box().min_width,
                                            containing_block_width);
         if computed_min_width > solution.width {
             input.computed_width = Specified(computed_min_width);
@@ -2233,11 +2233,11 @@ impl WidthAndMarginsComputer for AbsoluteReplaced {
                               ctx: &mut LayoutContext)
                               -> MaybeAuto {
         let containing_block_width = block.containing_block_size(ctx.screen_size).width;
-        let box_ = block.box_();
-        box_.assign_replaced_width_if_necessary(containing_block_width, None);
+        let fragment = block.fragment();
+        fragment.assign_replaced_width_if_necessary(containing_block_width, None);
         // For replaced absolute flow, the rest of the constraint solving will
         // take width to be specified as the value computed here.
-        Specified(box_.content_width())
+        Specified(fragment.content_width())
     }
 
     fn containing_block_width(&self, block: &mut BlockFlow, _: Au, ctx: &mut LayoutContext) -> Au {
@@ -2282,11 +2282,11 @@ impl WidthAndMarginsComputer for BlockReplaced {
                               parent_flow_width: Au,
                               _: &mut LayoutContext)
                               -> MaybeAuto {
-        let box_ = block.box_();
-        box_.assign_replaced_width_if_necessary(parent_flow_width, None);
+        let fragment = block.fragment();
+        fragment.assign_replaced_width_if_necessary(parent_flow_width, None);
         // For replaced block flow, the rest of the constraint solving will
         // take width to be specified as the value computed here.
-        Specified(box_.content_width())
+        Specified(fragment.content_width())
     }
 
 }
@@ -2338,11 +2338,11 @@ impl WidthAndMarginsComputer for FloatReplaced {
                               parent_flow_width: Au,
                               _: &mut LayoutContext)
                               -> MaybeAuto {
-        let box_ = block.box_();
-        box_.assign_replaced_width_if_necessary(parent_flow_width, None);
+        let fragment = block.fragment();
+        fragment.assign_replaced_width_if_necessary(parent_flow_width, None);
         // For replaced block flow, the rest of the constraint solving will
         // take width to be specified as the value computed here.
-        Specified(box_.content_width())
+        Specified(fragment.content_width())
     }
 }
 
diff --git a/src/components/main/layout/box_.rs b/src/components/main/layout/box_.rs
index bb7aebb4e30..a64d7d50290 100644
--- a/src/components/main/layout/box_.rs
+++ b/src/components/main/layout/box_.rs
@@ -51,24 +51,24 @@ use style::computed_values::{text_decoration, vertical_align, visibility, white_
 use sync::Arc;
 use url::Url;
 
-/// Boxes (`struct Box`) are the leaves of the layout tree. They cannot position themselves. In
-/// general, boxes do not have a simple correspondence with CSS boxes in the specification:
+/// Fragments (`struct Fragment`) are the leaves of the layout tree. They cannot position themselves. In
+/// general, fragments do not have a simple correspondence with CSS fragments in the specification:
 ///
-/// * Several boxes may correspond to the same CSS box or DOM node. For example, a CSS text box
-/// broken across two lines is represented by two boxes.
+/// * Several fragments may correspond to the same CSS box or DOM node. For example, a CSS text box
+/// broken across two lines is represented by two fragments.
 ///
-/// * Some CSS boxes are not created at all, such as some anonymous block boxes induced by inline
-///   boxes with block-level sibling boxes. In that case, Servo uses an `InlineFlow` with
+/// * Some CSS fragments are not created at all, such as some anonymous block fragments induced by inline
+///   fragments with block-level sibling fragments. In that case, Servo uses an `InlineFlow` with
 ///   `BlockFlow` siblings; the `InlineFlow` is block-level, but not a block container. It is
-///   positioned as if it were a block box, but its children are positioned according to inline
+///   positioned as if it were a block fragment, but its children are positioned according to inline
 ///   flow.
 ///
-/// A `GenericFragment` is an empty box that contributes only borders, margins, padding, and
+/// A `GenericFragment` is an empty fragment that contributes only borders, margins, padding, and
 /// backgrounds. It is analogous to a CSS nonreplaced content box.
 ///
-/// A box's type influences how its styles are interpreted during layout. For example, replaced
+/// A fragment's type influences how its styles are interpreted during layout. For example, replaced
 /// content such as images are resized differently from tables, text, or other content. Different
-/// types of boxes may also contain custom data; for example, text boxes contain text.
+/// types of fragments may also contain custom data; for example, text fragments contain text.
 ///
 /// FIXME(#2260, pcwalton): This can be slimmed down some.
 #[deriving(Clone)]
@@ -76,21 +76,21 @@ pub struct Fragment {
     /// An opaque reference to the DOM node that this `Fragment` originates from.
     pub node: OpaqueNode,
 
-    /// The CSS style of this box.
+    /// The CSS style of this fragment.
     pub style: Arc<ComputedValues>,
 
-    /// The position of this box relative to its owning flow.
+    /// The position of this fragment relative to its owning flow.
     /// The size includes padding and border, but not margin.
     pub border_box: Rect<Au>,
 
     /// The sum of border and padding; i.e. the distance from the edge of the border box to the
-    /// content edge of the box.
+    /// content edge of the fragment.
     pub border_padding: SideOffsets2D<Au>,
 
     /// The margin of the content box.
     pub margin: SideOffsets2D<Au>,
 
-    /// Info specific to the kind of box. Keep this enum small.
+    /// Info specific to the kind of fragment. Keep this enum small.
     pub specific: SpecificFragmentInfo,
 
     /// New-line chracter(\n)'s positions(relative, not absolute)
@@ -99,7 +99,7 @@ pub struct Fragment {
     pub new_line_pos: Vec<CharIndex>,
 }
 
-/// Info specific to the kind of box. Keep this enum small.
+/// Info specific to the kind of fragment. Keep this enum small.
 #[deriving(Clone)]
 pub enum SpecificFragmentInfo {
     GenericFragment,
@@ -114,10 +114,10 @@ pub enum SpecificFragmentInfo {
     UnscannedTextFragment(UnscannedTextFragmentInfo),
 }
 
-/// A box that represents a replaced content image and its accompanying borders, shadows, etc.
+/// A fragment that represents a replaced content image and its accompanying borders, shadows, etc.
 #[deriving(Clone)]
 pub struct ImageFragmentInfo {
-    /// The image held within this box.
+    /// The image held within this fragment.
     pub image: ImageHolder,
     pub computed_width: Option<Au>,
     pub computed_height: Option<Au>,
@@ -126,9 +126,9 @@ pub struct ImageFragmentInfo {
 }
 
 impl ImageFragmentInfo {
-    /// Creates a new image box from the given URL and local image cache.
+    /// Creates a new image fragment from the given URL and local image cache.
     ///
-    /// FIXME(pcwalton): The fact that image boxes store the cache in the box makes little sense to
+    /// FIXME(pcwalton): The fact that image fragments store the cache in the fragment makes little sense to
     /// me.
     pub fn new(node: &ThreadSafeLayoutNode,
                image_url: Url,
@@ -196,7 +196,7 @@ impl ImageFragmentInfo {
     }
 }
 
-/// A box that represents an inline frame (iframe). This stores the pipeline ID so that the size
+/// A fragment that represents an inline frame (iframe). This stores the pipeline ID so that the size
 /// of this iframe can be communicated via the constellation to the iframe's own layout task.
 #[deriving(Clone)]
 pub struct IframeFragmentInfo {
@@ -207,7 +207,7 @@ pub struct IframeFragmentInfo {
 }
 
 impl IframeFragmentInfo {
-    /// Creates the information specific to an iframe box.
+    /// Creates the information specific to an iframe fragment.
     pub fn new(node: &ThreadSafeLayoutNode) -> IframeFragmentInfo {
         let (pipeline_id, subpage_id) = node.iframe_pipeline_and_subpage_ids();
         IframeFragmentInfo {
@@ -217,10 +217,10 @@ impl IframeFragmentInfo {
     }
 }
 
-/// A scanned text box represents a single run of text with a distinct style. A `TextBox` may be
-/// split into two or more boxes across line breaks. Several `TextBox`es may correspond to a single
-/// DOM text node. Split text boxes are implemented by referring to subsets of a single `TextRun`
-/// object.
+/// A scanned text fragment represents a single run of text with a distinct style. A `TextFragment`
+/// may be split into two or more fragments across line breaks. Several `TextFragment`s may
+/// correspond to a single DOM text node. Split text fragments are implemented by referring to
+/// subsets of a single `TextRun` object.
 #[deriving(Clone)]
 pub struct ScannedTextFragmentInfo {
     /// The text run that this represents.
@@ -231,7 +231,7 @@ pub struct ScannedTextFragmentInfo {
 }
 
 impl ScannedTextFragmentInfo {
-    /// Creates the information specific to a scanned text box from a range and a text run.
+    /// Creates the information specific to a scanned text fragment from a range and a text run.
     pub fn new(run: Arc<Box<TextRun>>, range: Range<CharIndex>) -> ScannedTextFragmentInfo {
         ScannedTextFragmentInfo {
             run: run,
@@ -257,11 +257,11 @@ impl SplitInfo {
     }
 }
 
-/// Data for an unscanned text box. Unscanned text boxes are the results of flow construction that
+/// Data for an unscanned text fragment. Unscanned text fragments are the results of flow construction that
 /// have not yet had their width determined.
 #[deriving(Clone)]
 pub struct UnscannedTextFragmentInfo {
-    /// The text inside the box.
+    /// The text inside the fragment.
     pub text: ~str,
 }
 
@@ -283,7 +283,7 @@ impl UnscannedTextFragmentInfo {
     }
 }
 
-/// A box that represents a table column.
+/// A fragment that represents a table column.
 #[deriving(Clone)]
 pub struct TableColumnFragmentInfo {
     /// the number of columns a <col> element should span
@@ -291,7 +291,7 @@ pub struct TableColumnFragmentInfo {
 }
 
 impl TableColumnFragmentInfo {
-    /// Create the information specific to an table column box.
+    /// Create the information specific to an table column fragment.
     pub fn new(node: &ThreadSafeLayoutNode) -> TableColumnFragmentInfo {
         let span = {
             let element = node.as_element();
@@ -313,7 +313,7 @@ impl Fragment {
     ///
     ///   * `constructor`: The flow constructor.
     ///
-    ///   * `node`: The node to create a box for.
+    ///   * `node`: The node to create a fragment for.
     pub fn new(constructor: &mut FlowConstructor, node: &ThreadSafeLayoutNode) -> Fragment {
         Fragment {
             node: OpaqueNodeMethods::from_thread_safe_layout_node(node),
@@ -321,7 +321,7 @@ impl Fragment {
             border_box: Rect::zero(),
             border_padding: Zero::zero(),
             margin: Zero::zero(),
-            specific: constructor.build_specific_box_info_for_node(node),
+            specific: constructor.build_specific_fragment_info_for_node(node),
             new_line_pos: vec!(),
         }
     }
@@ -340,15 +340,15 @@ impl Fragment {
     }
 
     /// Constructs a new `Fragment` instance for an anonymous table object.
-    pub fn new_anonymous_table_box(node: &ThreadSafeLayoutNode, specific: SpecificFragmentInfo) -> Fragment {
-        // CSS 2.1 § 17.2.1 This is for non-inherited properties on anonymous table boxes
+    pub fn new_anonymous_table_fragment(node: &ThreadSafeLayoutNode, specific: SpecificFragmentInfo) -> Fragment {
+        // CSS 2.1 § 17.2.1 This is for non-inherited properties on anonymous table fragments
         // example:
         //
         //     <div style="display: table">
         //         Foo
         //     </div>
         //
-        // Anonymous table boxes, TableRowFragment and TableCellFragment, are generated around `Foo`, but it shouldn't inherit the border.
+        // Anonymous table fragments, TableRowFragment and TableCellFragment, are generated around `Foo`, but it shouldn't inherit the border.
 
         let node_style = cascade_anonymous(&**node.style());
         Fragment {
@@ -378,15 +378,15 @@ impl Fragment {
         }
     }
 
-    /// Returns a debug ID of this box. This ID should not be considered stable across multiple
-    /// layouts or box manipulations.
+    /// Returns a debug ID of this fragment. This ID should not be considered stable across multiple
+    /// layouts or fragment manipulations.
     pub fn debug_id(&self) -> uint {
         unsafe {
             cast::transmute(self)
         }
     }
 
-    /// Transforms this box into another box of the given type, with the given size, preserving all
+    /// Transforms this fragment into another fragment of the given type, with the given size, preserving all
     /// the other data.
     pub fn transform(&self, size: Size2D<Au>, specific: SpecificFragmentInfo) -> Fragment {
         Fragment {
@@ -409,7 +409,7 @@ impl Fragment {
             TableWrapperFragment => (true, false),
             TableRowFragment => (false, false),
             ScannedTextFragment(_) | TableColumnFragment(_) | UnscannedTextFragment(_) => {
-                // Styles are irrelevant for these kinds of boxes.
+                // Styles are irrelevant for these kinds of fragments.
                 return IntrinsicWidths::new()
             }
         };
@@ -541,7 +541,7 @@ impl Fragment {
             }
         }
 
-        // Go over the ancestor boxes and add all relative offsets (if any).
+        // Go over the ancestor fragments and add all relative offsets (if any).
         let mut rel_pos: Point2D<Au> = Zero::zero();
         match inline_fragment_context {
             None => {
@@ -603,7 +603,7 @@ impl Fragment {
         self.style().get_inheritedtext().white_space
     }
 
-    /// Returns the text decoration of this box, according to the style of the nearest ancestor
+    /// Returns the text decoration of this fragment, according to the style of the nearest ancestor
     /// element.
     ///
     /// NB: This may not be the actual text decoration, because of the override rules specified in
@@ -627,7 +627,7 @@ impl Fragment {
         }
     }
 
-    /// Returns true if this element can be split. This is true for text boxes.
+    /// Returns true if this element can be split. This is true for text fragments.
     pub fn can_split(&self) -> bool {
         match self.specific {
             ScannedTextFragment(..) => true,
@@ -635,8 +635,8 @@ impl Fragment {
         }
     }
 
-    /// Adds the display items necessary to paint the background of this box to the display list if
-    /// necessary.
+    /// Adds the display items necessary to paint the background of this fragment to the display
+    /// list if necessary.
     pub fn build_display_list_for_background_if_applicable(&self,
                                                            list: &mut DisplayList,
                                                            layout_context: &LayoutContext,
@@ -645,7 +645,7 @@ impl Fragment {
         // FIXME: This causes a lot of background colors to be displayed when they are clearly not
         // needed. We could use display list optimization to clean this up, but it still seems
         // inefficient. What we really want is something like "nearest ancestor element that
-        // doesn't have a box".
+        // doesn't have a fragment".
         let style = self.style();
         let background_color = style.resolve_color(style.get_background().background_color);
         if !background_color.alpha.approx_eq(&0.0) {
@@ -741,7 +741,7 @@ impl Fragment {
         }
     }
 
-    /// Adds the display items necessary to paint the borders of this box to a display list if
+    /// Adds the display items necessary to paint the borders of this fragment to a display list if
     /// necessary.
     pub fn build_display_list_for_borders_if_applicable(&self,
                                                         list: &mut DisplayList,
@@ -778,18 +778,18 @@ impl Fragment {
         list.push(BorderDisplayItemClass(border_display_item))
     }
 
-    fn build_debug_borders_around_text_boxes(&self,
+    fn build_debug_borders_around_text_fragments(&self,
                                              display_list: &mut DisplayList,
                                              flow_origin: Point2D<Au>,
-                                             text_box: &ScannedTextFragmentInfo) {
-        let box_bounds = self.border_box;
-        let absolute_box_bounds = box_bounds.translate(&flow_origin);
+                                             text_fragment: &ScannedTextFragmentInfo) {
+        let fragment_bounds = self.border_box;
+        let absolute_fragment_bounds = fragment_bounds.translate(&flow_origin);
 
-        // Compute the text box bounds and draw a border surrounding them.
+        // Compute the text fragment bounds and draw a border surrounding them.
         let debug_border = SideOffsets2D::new_all_same(Au::from_px(1));
 
         let border_display_item = box BorderDisplayItem {
-            base: BaseDisplayItem::new(absolute_box_bounds, self.node, ContentStackingLevel),
+            base: BaseDisplayItem::new(absolute_fragment_bounds, self.node, ContentStackingLevel),
             border: debug_border,
             color: SideOffsets2D::new_all_same(rgb(0, 0, 200)),
             style: SideOffsets2D::new_all_same(border_style::solid)
@@ -797,9 +797,9 @@ impl Fragment {
         display_list.push(BorderDisplayItemClass(border_display_item));
 
         // Draw a rectangle representing the baselines.
-        let ascent = text_box.run.ascent();
-        let baseline = Rect(absolute_box_bounds.origin + Point2D(Au(0), ascent),
-                            Size2D(absolute_box_bounds.size.width, Au(0)));
+        let ascent = text_fragment.run.ascent();
+        let baseline = Rect(absolute_fragment_bounds.origin + Point2D(Au(0), ascent),
+                            Size2D(absolute_fragment_bounds.size.width, Au(0)));
 
         let line_display_item = box LineDisplayItem {
             base: BaseDisplayItem::new(baseline, self.node, ContentStackingLevel),
@@ -809,17 +809,17 @@ impl Fragment {
         display_list.push(LineDisplayItemClass(line_display_item));
     }
 
-    fn build_debug_borders_around_box(&self,
+    fn build_debug_borders_around_fragment(&self,
                                       display_list: &mut DisplayList,
                                       flow_origin: Point2D<Au>) {
-        let box_bounds = self.border_box;
-        let absolute_box_bounds = box_bounds.translate(&flow_origin);
+        let fragment_bounds = self.border_box;
+        let absolute_fragment_bounds = fragment_bounds.translate(&flow_origin);
 
-        // This prints a debug border around the border of this box.
+        // This prints a debug border around the border of this fragment.
         let debug_border = SideOffsets2D::new_all_same(Au::from_px(1));
 
         let border_display_item = box BorderDisplayItem {
-            base: BaseDisplayItem::new(absolute_box_bounds, self.node, ContentStackingLevel),
+            base: BaseDisplayItem::new(absolute_fragment_bounds, self.node, ContentStackingLevel),
             border: debug_border,
             color: SideOffsets2D::new_all_same(rgb(0, 0, 200)),
             style: SideOffsets2D::new_all_same(border_style::solid)
@@ -827,7 +827,7 @@ impl Fragment {
         display_list.push(BorderDisplayItemClass(border_display_item))
     }
 
-    /// Adds the display items for this box to the given stacking context.
+    /// Adds the display items for this fragment to the given stacking context.
     ///
     /// Arguments:
     ///
@@ -835,7 +835,6 @@ impl Fragment {
     /// * `layout_context`: The layout context.
     /// * `dirty`: The dirty rectangle in the coordinate system of the owning flow.
     /// * `flow_origin`: Position of the origin of the owning flow wrt the display list root flow.
-    ///   box.
     pub fn build_display_list(&self,
                               display_list: &mut DisplayList,
                               layout_context: &LayoutContext,
@@ -844,25 +843,25 @@ impl Fragment {
                               inline_fragment_context: Option<InlineFragmentContext>)
                               -> ChildDisplayListAccumulator {
         // Fragment position wrt to the owning flow.
-        let box_bounds = self.border_box;
-        let absolute_box_bounds = box_bounds.translate(&flow_origin);
+        let fragment_bounds = self.border_box;
+        let absolute_fragment_bounds = fragment_bounds.translate(&flow_origin);
         debug!("Fragment::build_display_list at rel={}, abs={}: {}",
-               box_bounds,
-               absolute_box_bounds,
+               fragment_bounds,
+               absolute_fragment_bounds,
                self);
         debug!("Fragment::build_display_list: dirty={}, flow_origin={}",
                layout_context.dirty,
                flow_origin);
 
         let mut accumulator = ChildDisplayListAccumulator::new(self.style(),
-                                                               absolute_box_bounds,
+                                                               absolute_fragment_bounds,
                                                                self.node,
                                                                ContentStackingLevel);
         if self.style().get_inheritedbox().visibility != visibility::visible {
             return accumulator
         }
 
-        if !absolute_box_bounds.intersects(&layout_context.dirty) {
+        if !absolute_fragment_bounds.intersects(&layout_context.dirty) {
             debug!("Fragment::build_display_list: Did not intersect...");
             return accumulator
         }
@@ -874,29 +873,29 @@ impl Fragment {
                 StackingLevel::from_background_and_border_level(background_and_border_level);
 
             // Add a pseudo-display item for content box queries. This is a very bogus thing to do.
-            let base_display_item = box BaseDisplayItem::new(absolute_box_bounds, self.node, level);
+            let base_display_item = box BaseDisplayItem::new(absolute_fragment_bounds, self.node, level);
             display_list.push(PseudoDisplayItemClass(base_display_item));
 
             // Add the background to the list, if applicable.
             self.build_display_list_for_background_if_applicable(display_list,
                                                                  layout_context,
                                                                  level,
-                                                                 &absolute_box_bounds);
+                                                                 &absolute_fragment_bounds);
 
             // Add a border, if applicable.
             //
             // TODO: Outlines.
             self.build_display_list_for_borders_if_applicable(display_list,
-                                                              &absolute_box_bounds,
+                                                              &absolute_fragment_bounds,
                                                               level,
                                                               inline_fragment_context);
         }
 
         // Add a clip, if applicable.
         match self.specific {
-            UnscannedTextFragment(_) => fail!("Shouldn't see unscanned boxes here."),
-            TableColumnFragment(_) => fail!("Shouldn't see table column boxes here."),
-            ScannedTextFragment(ref text_box) => {
+            UnscannedTextFragment(_) => fail!("Shouldn't see unscanned fragments here."),
+            TableColumnFragment(_) => fail!("Shouldn't see table column fragments here."),
+            ScannedTextFragment(ref text_fragment) => {
                 // Compute text color.
                 let text_color = self.style().get_color().color.to_gfx_color();
 
@@ -911,15 +910,15 @@ impl Fragment {
                                                             .map(|c| c.to_gfx_color()),
                 };
 
-                let mut bounds = absolute_box_bounds.clone();
+                let mut bounds = absolute_fragment_bounds.clone();
                 bounds.origin.x = bounds.origin.x + self.border_padding.left;
                 bounds.size.width = bounds.size.width - self.border_padding.horizontal();
 
-                // Create the text box.
+                // Create the text fragment.
                 let text_display_item = box TextDisplayItem {
                     base: BaseDisplayItem::new(bounds, self.node, ContentStackingLevel),
-                    text_run: text_box.run.clone(),
-                    range: text_box.range,
+                    text_run: text_fragment.run.clone(),
+                    range: text_fragment.range,
                     text_color: text_color,
                     text_decorations: text_decorations,
                 };
@@ -929,29 +928,29 @@ impl Fragment {
                 //
                 // FIXME(#2263, pcwalton): This is a bit of an abuse of the logging infrastructure.
                 // We should have a real `SERVO_DEBUG` system.
-                debug!("{:?}", self.build_debug_borders_around_text_boxes(display_list,
+                debug!("{:?}", self.build_debug_borders_around_text_fragments(display_list,
                                                                           flow_origin,
-                                                                          text_box))
+                                                                          text_fragment))
             },
             GenericFragment | IframeFragment(..) | TableFragment | TableCellFragment | TableRowFragment |
             TableWrapperFragment => {
                 // FIXME(pcwalton): This is a bit of an abuse of the logging infrastructure. We
                 // should have a real `SERVO_DEBUG` system.
-                debug!("{:?}", self.build_debug_borders_around_box(display_list, flow_origin))
+                debug!("{:?}", self.build_debug_borders_around_fragment(display_list, flow_origin))
             },
             ImageFragment(_) => {
-                let mut bounds = absolute_box_bounds.clone();
+                let mut bounds = absolute_fragment_bounds.clone();
                 bounds.origin.x = bounds.origin.x + self.border_padding.left;
                 bounds.origin.y = bounds.origin.y + self.border_padding.top;
                 bounds.size.width = bounds.size.width - self.border_padding.horizontal();
                 bounds.size.height = bounds.size.height - self.border_padding.vertical();
 
                 match self.specific {
-                    ImageFragment(ref image_box) => {
-                        let image_ref = &image_box.image;
+                    ImageFragment(ref image_fragment) => {
+                        let image_ref = &image_fragment.image;
                         match image_ref.get_image_if_present() {
                             Some(image) => {
-                                debug!("(building display list) building image box");
+                                debug!("(building display list) building image fragment");
 
                                 // Place the image into the display list.
                                 let image_display_item = box ImageDisplayItem {
@@ -977,7 +976,7 @@ impl Fragment {
 
                 // FIXME(pcwalton): This is a bit of an abuse of the logging
                 // infrastructure. We should have a real `SERVO_DEBUG` system.
-                debug!("{:?}", self.build_debug_borders_around_box(display_list, flow_origin))
+                debug!("{:?}", self.build_debug_borders_around_fragment(display_list, flow_origin))
             }
         }
 
@@ -992,8 +991,8 @@ impl Fragment {
         // layout for the iframe only needs to know size, and origin is only relevant if the
         // iframe is actually going to be displayed.
         match self.specific {
-            IframeFragment(ref iframe_box) => {
-                self.finalize_position_and_size_of_iframe(iframe_box, flow_origin, layout_context)
+            IframeFragment(ref iframe_fragment) => {
+                self.finalize_position_and_size_of_iframe(iframe_fragment, flow_origin, layout_context)
             }
             _ => {}
         }
@@ -1009,28 +1008,28 @@ impl Fragment {
         match self.specific {
             GenericFragment | IframeFragment(_) | TableFragment | TableCellFragment | TableColumnFragment(_) | TableRowFragment |
             TableWrapperFragment => {}
-            ImageFragment(ref mut image_box_info) => {
-                let image_width = image_box_info.image_width();
+            ImageFragment(ref mut image_fragment_info) => {
+                let image_width = image_fragment_info.image_width();
                 result.minimum_width = geometry::max(result.minimum_width, image_width);
                 result.preferred_width = geometry::max(result.preferred_width, image_width);
             }
-            ScannedTextFragment(ref text_box_info) => {
-                let range = &text_box_info.range;
-                let min_line_width = text_box_info.run.min_width_for_range(range);
+            ScannedTextFragment(ref text_fragment_info) => {
+                let range = &text_fragment_info.range;
+                let min_line_width = text_fragment_info.run.min_width_for_range(range);
 
                 let mut max_line_width = Au::new(0);
-                for line_range in text_box_info.run.iter_natural_lines_for_range(range) {
-                    let line_metrics = text_box_info.run.metrics_for_range(&line_range);
+                for line_range in text_fragment_info.run.iter_natural_lines_for_range(range) {
+                    let line_metrics = text_fragment_info.run.metrics_for_range(&line_range);
                     max_line_width = Au::max(max_line_width, line_metrics.advance_width);
                 }
 
                 result.minimum_width = geometry::max(result.minimum_width, min_line_width);
                 result.preferred_width = geometry::max(result.preferred_width, max_line_width);
             }
-            UnscannedTextFragment(..) => fail!("Unscanned text boxes should have been scanned by now!"),
+            UnscannedTextFragment(..) => fail!("Unscanned text fragments should have been scanned by now!"),
         }
 
-        // Take borders and padding for parent inline boxes into account, if necessary.
+        // Take borders and padding for parent inline fragments into account, if necessary.
         match inline_fragment_context {
             None => {}
             Some(context) => {
@@ -1052,39 +1051,39 @@ impl Fragment {
         match self.specific {
             GenericFragment | IframeFragment(_) | TableFragment | TableCellFragment | TableRowFragment |
             TableWrapperFragment => Au(0),
-            ImageFragment(ref image_box_info) => {
-                image_box_info.computed_width()
+            ImageFragment(ref image_fragment_info) => {
+                image_fragment_info.computed_width()
             }
-            ScannedTextFragment(ref text_box_info) => {
-                let (range, run) = (&text_box_info.range, &text_box_info.run);
+            ScannedTextFragment(ref text_fragment_info) => {
+                let (range, run) = (&text_fragment_info.range, &text_fragment_info.run);
                 let text_bounds = run.metrics_for_range(range).bounding_box;
                 text_bounds.size.width
             }
-            TableColumnFragment(_) => fail!("Table column boxes do not have width"),
-            UnscannedTextFragment(_) => fail!("Unscanned text boxes should have been scanned by now!"),
+            TableColumnFragment(_) => fail!("Table column fragments do not have width"),
+            UnscannedTextFragment(_) => fail!("Unscanned text fragments should have been scanned by now!"),
         }
     }
 
-    /// Returns, and computes, the height of this box.
+    /// Returns, and computes, the height of this fragment.
     pub fn content_height(&self) -> Au {
         match self.specific {
             GenericFragment | IframeFragment(_) | TableFragment | TableCellFragment | TableRowFragment |
             TableWrapperFragment => Au(0),
-            ImageFragment(ref image_box_info) => {
-                image_box_info.computed_height()
+            ImageFragment(ref image_fragment_info) => {
+                image_fragment_info.computed_height()
             }
-            ScannedTextFragment(ref text_box_info) => {
+            ScannedTextFragment(ref text_fragment_info) => {
                 // Compute the height based on the line-height and font size.
                 //
                 // FIXME(pcwalton): Shouldn't we use the value of the `font-size` property below
                 // instead of the bounding box of the text run?
-                let (range, run) = (&text_box_info.range, &text_box_info.run);
+                let (range, run) = (&text_fragment_info.range, &text_fragment_info.run);
                 let text_bounds = run.metrics_for_range(range).bounding_box;
                 let em_size = text_bounds.size.height;
                 self.calculate_line_height(em_size)
             }
-            TableColumnFragment(_) => fail!("Table column boxes do not have height"),
-            UnscannedTextFragment(_) => fail!("Unscanned text boxes should have been scanned by now!"),
+            TableColumnFragment(_) => fail!("Table column fragments do not have height"),
+            UnscannedTextFragment(_) => fail!("Unscanned text fragments should have been scanned by now!"),
         }
     }
 
@@ -1102,82 +1101,81 @@ impl Fragment {
         }
     }
 
-    /// Find the split of a box that includes a new-line character.
+    /// Find the split of a fragment that includes a new-line character.
     ///
-    /// A return value of `None` indicates that the box is not splittable.
+    /// A return value of `None` indicates that the fragment is not splittable.
     /// Otherwise the split information is returned. The right information is
     /// optional due to the possibility of it being whitespace.
     //
     // TODO(bjz): The text run should be removed in the future, but it is currently needed for
-    // the current method of box splitting in the `inline::try_append_*` functions.
+    // the current method of fragment splitting in the `inline::try_append_*` functions.
     pub fn find_split_info_by_new_line(&self)
             -> Option<(SplitInfo, Option<SplitInfo>, Arc<Box<TextRun>> /* TODO(bjz): remove */)> {
         match self.specific {
             GenericFragment | IframeFragment(_) | ImageFragment(_) | TableFragment | TableCellFragment |
             TableRowFragment | TableWrapperFragment => None,
-            TableColumnFragment(_) => fail!("Table column boxes do not need to split"),
-            UnscannedTextFragment(_) => fail!("Unscanned text boxes should have been scanned by now!"),
-            ScannedTextFragment(ref text_box_info) => {
+            TableColumnFragment(_) => fail!("Table column fragments do not need to split"),
+            UnscannedTextFragment(_) => fail!("Unscanned text fragments should have been scanned by now!"),
+            ScannedTextFragment(ref text_fragment_info) => {
                 let mut new_line_pos = self.new_line_pos.clone();
                 let cur_new_line_pos = new_line_pos.shift().unwrap();
 
-                let left_range = Range::new(text_box_info.range.begin(), cur_new_line_pos);
-                let right_range = Range::new(text_box_info.range.begin() + cur_new_line_pos + CharIndex(1),
-                                             text_box_info.range.length() - (cur_new_line_pos + CharIndex(1)));
+                let left_range = Range::new(text_fragment_info.range.begin(), cur_new_line_pos);
+                let right_range = Range::new(text_fragment_info.range.begin() + cur_new_line_pos + CharIndex(1),
+                                             text_fragment_info.range.length() - (cur_new_line_pos + CharIndex(1)));
 
-                // Left box is for left text of first founded new-line character.
-                let left_box = SplitInfo::new(left_range, text_box_info);
+                // Left fragment is for left text of first founded new-line character.
+                let left_fragment = SplitInfo::new(left_range, text_fragment_info);
 
-                // Right box is for right text of first founded new-line character.
-                let right_box = if right_range.length() > CharIndex(0) {
-                    Some(SplitInfo::new(right_range, text_box_info))
+                // Right fragment is for right text of first founded new-line character.
+                let right_fragment = if right_range.length() > CharIndex(0) {
+                    Some(SplitInfo::new(right_range, text_fragment_info))
                 } else {
                     None
                 };
 
-                Some((left_box, right_box, text_box_info.run.clone()))
+                Some((left_fragment, right_fragment, text_fragment_info.run.clone()))
             }
         }
     }
 
-    /// Attempts to find the split positions of a text box so that its width is
+    /// Attempts to find the split positions of a text fragment so that its width is
     /// no more than `max_width`.
     ///
-    /// A return value of `None` indicates that the box could not be split.
+    /// A return value of `None` indicates that the fragment could not be split.
     /// Otherwise the information pertaining to the split is returned. The left
     /// and right split information are both optional due to the possibility of
     /// them being whitespace.
     //
     // TODO(bjz): The text run should be removed in the future, but it is currently needed for
-    // the current method of box splitting in the `inline::try_append_*` functions.
+    // the current method of fragment splitting in the `inline::try_append_*` functions.
     pub fn find_split_info_for_width(&self, start: CharIndex, max_width: Au, starts_line: bool)
             -> Option<(Option<SplitInfo>, Option<SplitInfo>, Arc<Box<TextRun>> /* TODO(bjz): remove */)> {
         match self.specific {
             GenericFragment | IframeFragment(_) | ImageFragment(_) | TableFragment | TableCellFragment |
             TableRowFragment | TableWrapperFragment => None,
-            TableColumnFragment(_) => fail!("Table column boxes do not have width"),
-            UnscannedTextFragment(_) => fail!("Unscanned text boxes should have been scanned by now!"),
-            ScannedTextFragment(ref text_box_info) => {
+            TableColumnFragment(_) => fail!("Table column fragments do not have width"),
+            UnscannedTextFragment(_) => fail!("Unscanned text fragments should have been scanned by now!"),
+            ScannedTextFragment(ref text_fragment_info) => {
                 let mut pieces_processed_count: uint = 0;
                 let mut remaining_width: Au = max_width;
-                let mut left_range = Range::new(text_box_info.range.begin() + start, CharIndex(0));
+                let mut left_range = Range::new(text_fragment_info.range.begin() + start, CharIndex(0));
                 let mut right_range: Option<Range<CharIndex>> = None;
 
-                debug!("split_to_width: splitting text box (strlen={:u}, range={}, \
-                                                            avail_width={})",
-                       text_box_info.run.text.len(),
-                       text_box_info.range,
+                debug!("split_to_width: splitting text fragment (strlen={}, range={}, avail_width={})",
+                       text_fragment_info.run.text.len(),
+                       text_fragment_info.range,
                        max_width);
 
-                for (glyphs, offset, slice_range) in text_box_info.run.iter_slices_for_range(
-                        &text_box_info.range) {
+                for (glyphs, offset, slice_range) in text_fragment_info.run.iter_slices_for_range(
+                        &text_fragment_info.range) {
                     debug!("split_to_width: considering slice (offset={}, range={}, \
                                                                remain_width={})",
                            offset,
                            slice_range,
                            remaining_width);
 
-                    let metrics = text_box_info.run.metrics_for_slice(glyphs, &slice_range);
+                    let metrics = text_fragment_info.run.metrics_for_slice(glyphs, &slice_range);
                     let advance = metrics.advance_width;
 
                     let should_continue;
@@ -1201,19 +1199,19 @@ impl Fragment {
                         if glyphs.is_whitespace() {
                             // If there are still things after the trimmable whitespace, create the
                             // right chunk.
-                            if slice_end < text_box_info.range.end() {
+                            if slice_end < text_fragment_info.range.end() {
                                 debug!("split_to_width: case=skipping trimmable trailing \
                                         whitespace, then split remainder");
-                                let right_range_end = text_box_info.range.end() - slice_end;
+                                let right_range_end = text_fragment_info.range.end() - slice_end;
                                 right_range = Some(Range::new(slice_end, right_range_end));
                             } else {
                                 debug!("split_to_width: case=skipping trimmable trailing \
                                         whitespace");
                             }
-                        } else if slice_begin < text_box_info.range.end() {
+                        } else if slice_begin < text_fragment_info.range.end() {
                             // There are still some things left over at the end of the line. Create
                             // the right chunk.
-                            let right_range_end = text_box_info.range.end() - slice_begin;
+                            let right_range_end = text_fragment_info.range.end() - slice_begin;
                             right_range = Some(Range::new(slice_begin, right_range_end));
                             debug!("split_to_width: case=splitting remainder with right range={:?}",
                                    right_range);
@@ -1233,28 +1231,28 @@ impl Fragment {
                     None
                 } else {
                     let left = if left_is_some {
-                        Some(SplitInfo::new(left_range, text_box_info))
+                        Some(SplitInfo::new(left_range, text_fragment_info))
                     } else {
                          None
                     };
-                    let right = right_range.map(|right_range| SplitInfo::new(right_range, text_box_info));
+                    let right = right_range.map(|right_range| SplitInfo::new(right_range, text_fragment_info));
 
-                    Some((left, right, text_box_info.run.clone()))
+                    Some((left, right, text_fragment_info.run.clone()))
                 }
             }
         }
     }
 
-    /// Returns true if this box is an unscanned text box that consists entirely of whitespace.
+    /// Returns true if this fragment is an unscanned text fragment that consists entirely of whitespace.
     pub fn is_whitespace_only(&self) -> bool {
         match self.specific {
-            UnscannedTextFragment(ref text_box_info) => is_whitespace(text_box_info.text),
+            UnscannedTextFragment(ref text_fragment_info) => is_whitespace(text_fragment_info.text),
             _ => false,
         }
     }
 
-    /// Assigns replaced width, padding, and margins for this box only if it is replaced content
-    /// per CSS 2.1 § 10.3.2.
+    /// Assigns replaced width, padding, and margins for this fragment only if it is replaced
+    /// content per CSS 2.1 § 10.3.2.
     pub fn assign_replaced_width_if_necessary(&mut self,
                                               container_width: Au,
                                               inline_fragment_context:
@@ -1262,8 +1260,8 @@ impl Fragment {
         match self.specific {
             GenericFragment | IframeFragment(_) | TableFragment | TableCellFragment | TableRowFragment |
             TableWrapperFragment => return,
-            TableColumnFragment(_) => fail!("Table column boxes do not have width"),
-            UnscannedTextFragment(_) => fail!("Unscanned text boxes should have been scanned by now!"),
+            TableColumnFragment(_) => fail!("Table column fragments do not have width"),
+            UnscannedTextFragment(_) => fail!("Unscanned text fragments should have been scanned by now!"),
             ImageFragment(_) | ScannedTextFragment(_) => {}
         };
 
@@ -1275,37 +1273,37 @@ impl Fragment {
 
         match self.specific {
             ScannedTextFragment(_) => {
-                // Scanned text boxes will have already had their content widths assigned by this
+                // Scanned text fragments will have already had their content widths assigned by this
                 // point.
                 self.border_box.size.width = self.border_box.size.width + noncontent_width
             }
-            ImageFragment(ref mut image_box_info) => {
+            ImageFragment(ref mut image_fragment_info) => {
                 // TODO(ksh8281): compute border,margin
                 let width = ImageFragmentInfo::style_length(style_width,
-                                                       image_box_info.dom_width,
+                                                       image_fragment_info.dom_width,
                                                        container_width);
                 let height = ImageFragmentInfo::style_length(style_height,
-                                                        image_box_info.dom_height,
+                                                        image_fragment_info.dom_height,
                                                         Au(0));
 
                 let width = match (width,height) {
-                    (Auto, Auto) => image_box_info.image_width(),
+                    (Auto, Auto) => image_fragment_info.image_width(),
                     (Auto,Specified(h)) => {
-                        let scale = image_box_info.
+                        let scale = image_fragment_info.
                             image_height().to_f32().unwrap() / h.to_f32().unwrap();
-                        Au::new((image_box_info.image_width().to_f32().unwrap() / scale) as i32)
+                        Au::new((image_fragment_info.image_width().to_f32().unwrap() / scale) as i32)
                     },
                     (Specified(w), _) => w,
                 };
 
                 self.border_box.size.width = width + noncontent_width;
-                image_box_info.computed_width = Some(width);
+                image_fragment_info.computed_width = Some(width);
             }
             _ => fail!("this case should have been handled above"),
         }
     }
 
-    /// Assign height for this box if it is replaced content. The width must have been assigned
+    /// Assign height for this fragment if it is replaced content. The width must have been assigned
     /// first.
     ///
     /// Ideally, this should follow CSS 2.1 § 10.6.2.
@@ -1313,8 +1311,8 @@ impl Fragment {
         match self.specific {
             GenericFragment | IframeFragment(_) | TableFragment | TableCellFragment | TableRowFragment |
             TableWrapperFragment => return,
-            TableColumnFragment(_) => fail!("Table column boxes do not have height"),
-            UnscannedTextFragment(_) => fail!("Unscanned text boxes should have been scanned by now!"),
+            TableColumnFragment(_) => fail!("Table column fragments do not have height"),
+            UnscannedTextFragment(_) => fail!("Unscanned text fragments should have been scanned by now!"),
             ImageFragment(_) | ScannedTextFragment(_) => {}
         }
 
@@ -1323,34 +1321,34 @@ impl Fragment {
         let noncontent_height = self.border_padding.vertical();
 
         match self.specific {
-            ImageFragment(ref mut image_box_info) => {
+            ImageFragment(ref mut image_fragment_info) => {
                 // TODO(ksh8281): compute border,margin,padding
-                let width = image_box_info.computed_width();
+                let width = image_fragment_info.computed_width();
                 // FIXME(ksh8281): we shouldn't assign height this way
                 // we don't know about size of parent's height
                 let height = ImageFragmentInfo::style_length(style_height,
-                                                        image_box_info.dom_height,
+                                                        image_fragment_info.dom_height,
                                                         Au(0));
 
-                let height = match (style_width, image_box_info.dom_width, height) {
+                let height = match (style_width, image_fragment_info.dom_width, height) {
                     (LPA_Auto, None, Auto) => {
-                        image_box_info.image_height()
+                        image_fragment_info.image_height()
                     },
                     (_,_,Auto) => {
-                        let scale = image_box_info.image_width().to_f32().unwrap()
+                        let scale = image_fragment_info.image_width().to_f32().unwrap()
                             / width.to_f32().unwrap();
-                        Au::new((image_box_info.image_height().to_f32().unwrap() / scale) as i32)
+                        Au::new((image_fragment_info.image_height().to_f32().unwrap() / scale) as i32)
                     },
                     (_,_,Specified(h)) => {
                         h
                     }
                 };
 
-                image_box_info.computed_height = Some(height);
+                image_fragment_info.computed_height = Some(height);
                 self.border_box.size.height = height + noncontent_height
             }
             ScannedTextFragment(_) => {
-                // Scanned text boxes' content heights are calculated by the text run scanner
+                // Scanned text fragments' content heights are calculated by the text run scanner
                 // during flow construction.
                 self.border_box.size.height = self.border_box.size.height + noncontent_height
             }
@@ -1362,19 +1360,19 @@ impl Fragment {
     /// used in an inline formatting context. See CSS 2.1 § 10.8.1.
     pub fn inline_metrics(&self) -> InlineMetrics {
         match self.specific {
-            ImageFragment(ref image_box_info) => {
-                let computed_height = image_box_info.computed_height();
+            ImageFragment(ref image_fragment_info) => {
+                let computed_height = image_fragment_info.computed_height();
                 InlineMetrics {
                     height_above_baseline: computed_height + self.border_padding.vertical(),
                     depth_below_baseline: Au(0),
                     ascent: computed_height + self.border_padding.bottom,
                 }
             }
-            ScannedTextFragment(ref text_box) => {
+            ScannedTextFragment(ref text_fragment) => {
                 // See CSS 2.1 § 10.8.1.
                 let font_size = self.style().get_font().font_size;
                 let line_height = self.calculate_line_height(font_size);
-                InlineMetrics::from_font_metrics(&text_box.run.font_metrics, line_height)
+                InlineMetrics::from_font_metrics(&text_fragment.run.font_metrics, line_height)
             }
             _ => {
                 InlineMetrics {
@@ -1386,8 +1384,8 @@ impl Fragment {
         }
     }
 
-    /// Returns true if this box can merge with another adjacent box or false otherwise.
-    pub fn can_merge_with_box(&self, other: &Fragment) -> bool {
+    /// Returns true if this fragment can merge with another adjacent fragment or false otherwise.
+    pub fn can_merge_with_fragment(&self, other: &Fragment) -> bool {
         match (&self.specific, &other.specific) {
             (&UnscannedTextFragment(_), &UnscannedTextFragment(_)) => {
                 self.font_style() == other.font_style() &&
@@ -1419,11 +1417,11 @@ impl Fragment {
         }
     }
 
-    /// Sends the size and position of this iframe box to the constellation. This is out of line to
-    /// guide inlining.
+    /// Sends the size and position of this iframe fragment to the constellation. This is out of
+    /// line to guide inlining.
     #[inline(never)]
     fn finalize_position_and_size_of_iframe(&self,
-                                            iframe_box: &IframeFragmentInfo,
+                                            iframe_fragment: &IframeFragmentInfo,
                                             offset: Point2D<Au>,
                                             layout_context: &LayoutContext) {
         let left = offset.x + self.margin.left + self.border_padding.left;
@@ -1435,16 +1433,16 @@ impl Fragment {
         let rect = Rect(origin, size);
 
         debug!("finalizing position and size of iframe for {:?},{:?}",
-               iframe_box.pipeline_id,
-               iframe_box.subpage_id);
-        let msg = FrameRectMsg(iframe_box.pipeline_id, iframe_box.subpage_id, rect);
+               iframe_fragment.pipeline_id,
+               iframe_fragment.subpage_id);
+        let msg = FrameRectMsg(iframe_fragment.pipeline_id, iframe_fragment.subpage_id, rect);
         let ConstellationChan(ref chan) = layout_context.constellation_chan;
         chan.send(msg)
     }
 }
 
 impl fmt::Show for Fragment {
-    /// Outputs a debugging string describing this box.
+    /// Outputs a debugging string describing this fragment.
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         try!(write!(f.buf, "({} ",
             match self.specific {
diff --git a/src/components/main/layout/construct.rs b/src/components/main/layout/construct.rs
index e5e732fe59a..84540657c81 100644
--- a/src/components/main/layout/construct.rs
+++ b/src/components/main/layout/construct.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/. */
 
-//! Creates flows and boxes from a DOM tree via a bottom-up, incremental traversal of the DOM.
+//! Creates flows and fragments from a DOM tree via a bottom-up, incremental traversal of the DOM.
 //!
 //! Each step of the traversal considers the node and existing flow, if there is one. If a node is
 //! not dirty and an existing flow exists, then the traversal reuses that flow. Otherwise, it
@@ -95,7 +95,7 @@ impl ConstructionResult {
 /// complete flow. Construction items bubble up the tree until they find a `Flow` to be
 /// attached to.
 pub enum ConstructionItem {
-    /// Inline boxes and associated {ib} splits that have not yet found flows.
+    /// Inline fragments and associated {ib} splits that have not yet found flows.
     InlineFragmentsConstructionItem(InlineFragmentsConstructionResult),
     /// Potentially ignorable whitespace.
     WhitespaceConstructionItem(OpaqueNode, Arc<ComputedValues>),
@@ -117,13 +117,13 @@ impl ConstructionItem {
     }
 }
 
-/// Represents inline boxes and {ib} splits that are bubbling up from an inline.
+/// Represents inline fragments and {ib} splits that are bubbling up from an inline.
 pub struct InlineFragmentsConstructionResult {
     /// Any {ib} splits that we're bubbling up.
     pub splits: Vec<InlineBlockSplit>,
 
-    /// Any boxes that succeed the {ib} splits.
-    pub boxes: InlineFragments,
+    /// Any fragments that succeed the {ib} splits.
+    pub fragments: InlineFragments,
 
     /// Any absolute descendants that we're bubbling up.
     pub abs_descendants: AbsDescendants,
@@ -142,7 +142,7 @@ pub struct InlineFragmentsConstructionResult {
 ///
 ///     InlineFragmentsConstructionItem(Some(~[
 ///         InlineBlockSplit {
-///             predecessor_boxes: ~[
+///             predecessor_fragments: ~[
 ///                 A
 ///             ],
 ///             block: ~BlockFlow {
@@ -152,7 +152,7 @@ pub struct InlineFragmentsConstructionResult {
 ///             C
 ///         ])
 pub struct InlineBlockSplit {
-    /// The inline boxes that precede the flow.
+    /// The inline fragments that precede the flow.
     pub predecessors: InlineFragments,
 
     /// The flow that caused this {ib} split.
@@ -165,12 +165,12 @@ impl InlineBlockSplit {
     }
 }
 
-/// Holds inline boxes that we're gathering for children of an inline node.
+/// Holds inline fragments that we're gathering for children of an inline node.
 struct InlineFragmentsAccumulator {
-    /// The list of boxes.
-    boxes: InlineFragments,
+    /// The list of fragments.
+    fragments: InlineFragments,
 
-    /// Whether we've created a range to enclose all the boxes. This will be true if the outer node
+    /// Whether we've created a range to enclose all the fragments. This will be true if the outer node
     /// is an inline and false otherwise.
     has_enclosing_range: bool,
 }
@@ -178,31 +178,31 @@ struct InlineFragmentsAccumulator {
 impl InlineFragmentsAccumulator {
     fn new() -> InlineFragmentsAccumulator {
         InlineFragmentsAccumulator {
-            boxes: InlineFragments::new(),
+            fragments: InlineFragments::new(),
             has_enclosing_range: false,
         }
     }
 
     fn from_inline_node(node: &ThreadSafeLayoutNode) -> InlineFragmentsAccumulator {
-        let mut boxes = InlineFragments::new();
-        boxes.map.push(node.style().clone(), Range::empty());
+        let mut fragments = InlineFragments::new();
+        fragments.map.push(node.style().clone(), Range::empty());
         InlineFragmentsAccumulator {
-            boxes: boxes,
+            fragments: fragments,
             has_enclosing_range: true,
         }
     }
 
     fn finish(self) -> InlineFragments {
         let InlineFragmentsAccumulator {
-            boxes: mut boxes,
+            fragments: mut fragments,
             has_enclosing_range
         } = self;
 
         if has_enclosing_range {
-            let len = FragmentIndex(boxes.len() as int);
-            boxes.map.get_mut(FragmentIndex(0)).range.extend_to(len);
+            let len = FragmentIndex(fragments.len() as int);
+            fragments.map.get_mut(FragmentIndex(0)).range.extend_to(len);
         }
-        boxes
+        fragments
     }
 }
 
@@ -255,12 +255,12 @@ impl<'a> FlowConstructor<'a> {
     }
 
     /// Builds the `ImageFragmentInfo` for the given image. This is out of line to guide inlining.
-    fn build_box_info_for_image(&mut self, node: &ThreadSafeLayoutNode, url: Option<Url>)
+    fn build_fragment_info_for_image(&mut self, node: &ThreadSafeLayoutNode, url: Option<Url>)
                                 -> SpecificFragmentInfo {
         match url {
             None => GenericFragment,
             Some(url) => {
-                // FIXME(pcwalton): The fact that image boxes store the cache within them makes
+                // FIXME(pcwalton): The fact that image fragments store the cache within them makes
                 // little sense to me.
                 ImageFragment(ImageFragmentInfo::new(node, url, self.layout_context.image_cache.clone()))
             }
@@ -268,18 +268,18 @@ impl<'a> FlowConstructor<'a> {
     }
 
     /// Builds specific `Fragment` info for the given node.
-    pub fn build_specific_box_info_for_node(&mut self, node: &ThreadSafeLayoutNode)
+    pub fn build_specific_fragment_info_for_node(&mut self, node: &ThreadSafeLayoutNode)
                                             -> SpecificFragmentInfo {
         match node.type_id() {
             Some(ElementNodeTypeId(HTMLImageElementTypeId)) => {
-                self.build_box_info_for_image(node, node.image_url())
+                self.build_fragment_info_for_image(node, node.image_url())
             }
             Some(ElementNodeTypeId(HTMLIFrameElementTypeId)) => {
                 IframeFragment(IframeFragmentInfo::new(node))
             }
             Some(ElementNodeTypeId(HTMLObjectElementTypeId)) => {
                 let data = node.get_object_data(&self.layout_context.url);
-                self.build_box_info_for_image(node, data)
+                self.build_fragment_info_for_image(node, data)
             }
             Some(ElementNodeTypeId(HTMLTableElementTypeId)) => TableWrapperFragment,
             Some(ElementNodeTypeId(HTMLTableColElementTypeId)) => {
@@ -294,40 +294,40 @@ impl<'a> FlowConstructor<'a> {
         }
     }
 
-    /// Creates an inline flow from a set of inline boxes, then adds it as a child of the given flow
+    /// Creates an inline flow from a set of inline fragments, then adds it as a child of the given flow
     /// or pushes it onto the given flow list.
     ///
     /// `#[inline(always)]` because this is performance critical and LLVM will not inline it
     /// otherwise.
     #[inline(always)]
-    fn flush_inline_boxes_to_flow_or_list(&mut self,
-                                          box_accumulator: InlineFragmentsAccumulator,
+    fn flush_inline_fragments_to_flow_or_list(&mut self,
+                                          fragment_accumulator: InlineFragmentsAccumulator,
                                           flow: &mut Box<Flow:Share>,
                                           flow_list: &mut Vec<Box<Flow:Share>>,
                                           whitespace_stripping: WhitespaceStrippingMode,
                                           node: &ThreadSafeLayoutNode) {
-        let mut boxes = box_accumulator.finish();
-        if boxes.len() == 0 {
+        let mut fragments = fragment_accumulator.finish();
+        if fragments.len() == 0 {
             return
         }
 
         match whitespace_stripping {
             NoWhitespaceStripping => {}
             StripWhitespaceFromStart => {
-                strip_ignorable_whitespace_from_start(&mut boxes);
-                if boxes.len() == 0 {
+                strip_ignorable_whitespace_from_start(&mut fragments);
+                if fragments.len() == 0 {
                     return
                 }
             }
             StripWhitespaceFromEnd => {
-                strip_ignorable_whitespace_from_end(&mut boxes);
-                if boxes.len() == 0 {
+                strip_ignorable_whitespace_from_end(&mut fragments);
+                if fragments.len() == 0 {
                     return
                 }
             }
         }
 
-        let mut inline_flow = box InlineFlow::from_boxes((*node).clone(), boxes);
+        let mut inline_flow = box InlineFlow::from_fragments((*node).clone(), fragments);
         inline_flow.compute_minimum_ascent_and_descent(self.font_context(), &**node.style());
         let mut inline_flow = inline_flow as Box<Flow:Share>;
         TextRunScanner::new().scan_for_runs(self.font_context(), inline_flow);
@@ -343,13 +343,13 @@ impl<'a> FlowConstructor<'a> {
     fn build_block_flow_using_children_construction_result(&mut self,
                                                            flow: &mut Box<Flow:Share>,
                                                            consecutive_siblings:
-                                                                &mut Vec<Box<Flow:Share>>,
+                                                           &mut Vec<Box<Flow:Share>>,
                                                            node: &ThreadSafeLayoutNode,
                                                            kid: ThreadSafeLayoutNode,
-                                                           inline_box_accumulator:
-                                                                &mut InlineFragmentsAccumulator,
+                                                           inline_fragment_accumulator:
+                                                           &mut InlineFragmentsAccumulator,
                                                            abs_descendants: &mut Descendants,
-                                                           first_box: &mut bool) {
+                                                           first_fragment: &mut bool) {
         match kid.swap_out_construction_result() {
             NoConstructionResult => {}
             FlowConstructionResult(kid_flow, kid_abs_descendants) => {
@@ -364,19 +364,19 @@ impl<'a> FlowConstructor<'a> {
                 } else {
                     // Strip ignorable whitespace from the start of this flow per CSS 2.1 §
                     // 9.2.1.1.
-                    let whitespace_stripping = if flow.is_table_kind() || *first_box {
-                        *first_box = false;
+                    let whitespace_stripping = if flow.is_table_kind() || *first_fragment {
+                        *first_fragment = false;
                         StripWhitespaceFromStart
                     } else {
                         NoWhitespaceStripping
                     };
 
-                    // Flush any inline boxes that we were gathering up. This allows us to handle
+                    // Flush any inline fragments that we were gathering up. This allows us to handle
                     // {ib} splits.
                     debug!("flushing {} inline box(es) to flow A",
-                           inline_box_accumulator.boxes.len());
-                    self.flush_inline_boxes_to_flow_or_list(
-                        mem::replace(inline_box_accumulator, InlineFragmentsAccumulator::new()),
+                           inline_fragment_accumulator.fragments.len());
+                    self.flush_inline_fragments_to_flow_or_list(
+                        mem::replace(inline_fragment_accumulator, InlineFragmentsAccumulator::new()),
                         flow,
                         consecutive_siblings,
                         whitespace_stripping,
@@ -394,33 +394,33 @@ impl<'a> FlowConstructor<'a> {
             ConstructionItemConstructionResult(InlineFragmentsConstructionItem(
                     InlineFragmentsConstructionResult {
                         splits: splits,
-                        boxes: successor_boxes,
+                        fragments: successor_fragments,
                         abs_descendants: kid_abs_descendants,
                     })) => {
                 // Add any {ib} splits.
                 for split in splits.move_iter() {
-                    // Pull apart the {ib} split object and push its predecessor boxes
+                    // Pull apart the {ib} split object and push its predecessor fragments
                     // onto the list.
                     let InlineBlockSplit {
                         predecessors: predecessors,
                         flow: kid_flow
                     } = split;
-                    inline_box_accumulator.boxes.push_all(predecessors);
+                    inline_fragment_accumulator.fragments.push_all(predecessors);
 
-                    // If this is the first box in flow, then strip ignorable
+                    // If this is the first fragment in flow, then strip ignorable
                     // whitespace per CSS 2.1 § 9.2.1.1.
-                    let whitespace_stripping = if *first_box {
-                        *first_box = false;
+                    let whitespace_stripping = if *first_fragment {
+                        *first_fragment = false;
                         StripWhitespaceFromStart
                     } else {
                         NoWhitespaceStripping
                     };
 
-                    // Flush any inline boxes that we were gathering up.
+                    // Flush any inline fragments that we were gathering up.
                     debug!("flushing {} inline box(es) to flow A",
-                           inline_box_accumulator.boxes.len());
-                    self.flush_inline_boxes_to_flow_or_list(
-                            mem::replace(inline_box_accumulator,
+                           inline_fragment_accumulator.fragments.len());
+                    self.flush_inline_fragments_to_flow_or_list(
+                            mem::replace(inline_fragment_accumulator,
                                          InlineFragmentsAccumulator::new()),
                             flow,
                             consecutive_siblings,
@@ -436,8 +436,8 @@ impl<'a> FlowConstructor<'a> {
                     }
                 }
 
-                // Add the boxes to the list we're maintaining.
-                inline_box_accumulator.boxes.push_all(successor_boxes);
+                // Add the fragments to the list we're maintaining.
+                inline_fragment_accumulator.fragments.push_all(successor_fragments);
                 abs_descendants.push_descendants(kid_abs_descendants);
             }
             ConstructionItemConstructionResult(WhitespaceConstructionItem(..)) => {
@@ -461,10 +461,10 @@ impl<'a> FlowConstructor<'a> {
                                  mut flow: Box<Flow:Share>,
                                  node: &ThreadSafeLayoutNode)
                                  -> ConstructionResult {
-        // Gather up boxes for the inline flows we might need to create.
-        let mut inline_box_accumulator = InlineFragmentsAccumulator::new();
+        // Gather up fragments for the inline flows we might need to create.
+        let mut inline_fragment_accumulator = InlineFragmentsAccumulator::new();
         let mut consecutive_siblings = vec!();
-        let mut first_box = true;
+        let mut first_fragment = true;
 
         // List of absolute descendants, in tree order.
         let mut abs_descendants = Descendants::new();
@@ -477,14 +477,14 @@ impl<'a> FlowConstructor<'a> {
                                                                      &mut consecutive_siblings,
                                                                      node,
                                                                      kid,
-                                                                     &mut inline_box_accumulator,
+                                                                     &mut inline_fragment_accumulator,
                                                                      &mut abs_descendants,
-                                                                     &mut first_box);
+                                                                     &mut first_fragment);
         }
 
-        // Perform a final flush of any inline boxes that we were gathering up to handle {ib}
+        // Perform a final flush of any inline fragments that we were gathering up to handle {ib}
         // splits, after stripping ignorable whitespace.
-        self.flush_inline_boxes_to_flow_or_list(inline_box_accumulator,
+        self.flush_inline_fragments_to_flow_or_list(inline_fragment_accumulator,
                                                 &mut flow,
                                                 &mut consecutive_siblings,
                                                 StripWhitespaceFromEnd,
@@ -528,16 +528,16 @@ impl<'a> FlowConstructor<'a> {
         self.build_flow_using_children(flow, node)
     }
 
-    /// Concatenates the boxes of kids, adding in our own borders/padding/margins if necessary.
+    /// Concatenates the fragments of kids, adding in our own borders/padding/margins if necessary.
     /// Returns the `InlineFragmentsConstructionResult`, if any. There will be no
     /// `InlineFragmentsConstructionResult` if this node consisted entirely of ignorable whitespace.
-    fn build_boxes_for_nonreplaced_inline_content(&mut self, node: &ThreadSafeLayoutNode)
+    fn build_fragments_for_nonreplaced_inline_content(&mut self, node: &ThreadSafeLayoutNode)
                                                   -> ConstructionResult {
         let mut opt_inline_block_splits: Vec<InlineBlockSplit> = Vec::new();
-        let mut box_accumulator = InlineFragmentsAccumulator::from_inline_node(node);
+        let mut fragment_accumulator = InlineFragmentsAccumulator::from_inline_node(node);
         let mut abs_descendants = Descendants::new();
 
-        // Concatenate all the boxes of our kids, creating {ib} splits as necessary.
+        // Concatenate all the fragments of our kids, creating {ib} splits as necessary.
         for kid in node.children() {
             if kid.get_pseudo_element_type() != Normal {
                 self.process(&kid);
@@ -546,10 +546,10 @@ impl<'a> FlowConstructor<'a> {
                 NoConstructionResult => {}
                 FlowConstructionResult(flow, kid_abs_descendants) => {
                     // {ib} split. Flush the accumulator to our new split and make a new
-                    // accumulator to hold any subsequent boxes we come across.
+                    // accumulator to hold any subsequent fragments we come across.
                     let split = InlineBlockSplit {
                         predecessors:
-                            mem::replace(&mut box_accumulator,
+                            mem::replace(&mut fragment_accumulator,
                                          InlineFragmentsAccumulator::from_inline_node(node)).finish(),
                         flow: flow,
                     };
@@ -559,7 +559,7 @@ impl<'a> FlowConstructor<'a> {
                 ConstructionItemConstructionResult(InlineFragmentsConstructionItem(
                         InlineFragmentsConstructionResult {
                             splits: splits,
-                            boxes: successors,
+                            fragments: successors,
                             abs_descendants: kid_abs_descendants,
                         })) => {
 
@@ -569,11 +569,11 @@ impl<'a> FlowConstructor<'a> {
                             predecessors: predecessors,
                             flow: kid_flow
                         } = split;
-                        box_accumulator.boxes.push_all(predecessors);
+                        fragment_accumulator.fragments.push_all(predecessors);
 
                         let split = InlineBlockSplit {
                             predecessors:
-                                mem::replace(&mut box_accumulator,
+                                mem::replace(&mut fragment_accumulator,
                                              InlineFragmentsAccumulator::from_inline_node(node))
                                     .finish(),
                             flow: kid_flow,
@@ -581,19 +581,19 @@ impl<'a> FlowConstructor<'a> {
                         opt_inline_block_splits.push(split)
                     }
 
-                    // Push residual boxes.
-                    box_accumulator.boxes.push_all(successors);
+                    // Push residual fragments.
+                    fragment_accumulator.fragments.push_all(successors);
                     abs_descendants.push_descendants(kid_abs_descendants);
                 }
                 ConstructionItemConstructionResult(WhitespaceConstructionItem(whitespace_node,
                                                                               whitespace_style))
                         => {
-                    // Instantiate the whitespace box.
-                    let box_info = UnscannedTextFragment(UnscannedTextFragmentInfo::from_text(" ".to_owned()));
+                    // Instantiate the whitespace fragment.
+                    let fragment_info = UnscannedTextFragment(UnscannedTextFragmentInfo::from_text(" ".to_owned()));
                     let fragment = Fragment::from_opaque_node_and_style(whitespace_node,
                                                                    whitespace_style.clone(),
-                                                                   box_info);
-                    box_accumulator.boxes.push(fragment, whitespace_style)
+                                                                   fragment_info);
+                    fragment_accumulator.fragments.push(fragment, whitespace_style)
                 }
                 ConstructionItemConstructionResult(TableColumnFragmentConstructionItem(_)) => {
                     // TODO: Implement anonymous table objects for missing parents
@@ -603,11 +603,11 @@ impl<'a> FlowConstructor<'a> {
         }
 
         // Finally, make a new construction result.
-        if opt_inline_block_splits.len() > 0 || box_accumulator.boxes.len() > 0
+        if opt_inline_block_splits.len() > 0 || fragment_accumulator.fragments.len() > 0
                 || abs_descendants.len() > 0 {
             let construction_item = InlineFragmentsConstructionItem(InlineFragmentsConstructionResult {
                 splits: opt_inline_block_splits,
-                boxes: box_accumulator.finish(),
+                fragments: fragment_accumulator.finish(),
                 abs_descendants: abs_descendants,
             });
             ConstructionItemConstructionResult(construction_item)
@@ -617,8 +617,8 @@ impl<'a> FlowConstructor<'a> {
     }
 
     /// Creates an `InlineFragmentsConstructionResult` for replaced content. Replaced content doesn't
-    /// render its children, so this just nukes a child's boxes and creates a `Fragment`.
-    fn build_boxes_for_replaced_inline_content(&mut self, node: &ThreadSafeLayoutNode)
+    /// render its children, so this just nukes a child's fragments and creates a `Fragment`.
+    fn build_fragments_for_replaced_inline_content(&mut self, node: &ThreadSafeLayoutNode)
                                                -> ConstructionResult {
         for kid in node.children() {
             kid.set_flow_construction_result(NoConstructionResult)
@@ -634,27 +634,28 @@ impl<'a> FlowConstructor<'a> {
                 node.style().clone()))
         }
 
-        let mut boxes = InlineFragments::new();
-        boxes.push(Fragment::new(self, node), node.style().clone());
+        let mut fragments = InlineFragments::new();
+        fragments.push(Fragment::new(self, node), node.style().clone());
 
         let construction_item = InlineFragmentsConstructionItem(InlineFragmentsConstructionResult {
             splits: Vec::new(),
-            boxes: boxes,
+            fragments: fragments,
             abs_descendants: Descendants::new(),
         });
         ConstructionItemConstructionResult(construction_item)
     }
 
-    /// Builds one or more boxes for a node with `display: inline`. This yields an
+    /// Builds one or more fragments for a node with `display: inline`. This yields an
     /// `InlineFragmentsConstructionResult`.
-    fn build_boxes_for_inline(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult {
+    fn build_fragments_for_inline(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult {
         // Is this node replaced content?
         if !node.is_replaced_content() {
-            // Go to a path that concatenates our kids' boxes.
-            self.build_boxes_for_nonreplaced_inline_content(node)
+            // Go to a path that concatenates our kids' fragments.
+            self.build_fragments_for_nonreplaced_inline_content(node)
         } else {
-            // Otherwise, just nuke our kids' boxes, create our box if any, and be done with it.
-            self.build_boxes_for_replaced_inline_content(node)
+            // Otherwise, just nuke our kids' fragments, create our fragment if any, and be done
+            // with it.
+            self.build_fragments_for_replaced_inline_content(node)
         }
     }
 
@@ -704,11 +705,11 @@ impl<'a> FlowConstructor<'a> {
     /// Builds a flow for a node with `display: table`. This yields a `TableWrapperFlow` with possibly
     /// other `TableCaptionFlow`s or `TableFlow`s underneath it.
     fn build_flow_for_table_wrapper(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult {
-        let box_ = Fragment::new_from_specific_info(node, TableWrapperFragment);
-        let mut wrapper_flow = box TableWrapperFlow::from_node_and_box(node, box_) as Box<Flow:Share>;
+        let fragment = Fragment::new_from_specific_info(node, TableWrapperFragment);
+        let mut wrapper_flow = box TableWrapperFlow::from_node_and_fragment(node, fragment) as Box<Flow:Share>;
 
-        let table_box_ = Fragment::new_from_specific_info(node, TableFragment);
-        let table_flow = box TableFlow::from_node_and_box(node, table_box_) as Box<Flow:Share>;
+        let table_fragment = Fragment::new_from_specific_info(node, TableFragment);
+        let table_flow = box TableFlow::from_node_and_fragment(node, table_fragment) as Box<Flow:Share>;
 
         // We first populate the TableFlow with other flows than TableCaptionFlow.
         // We then populate the TableWrapperFlow with TableCaptionFlow, and attach
@@ -761,30 +762,30 @@ impl<'a> FlowConstructor<'a> {
     /// Builds a flow for a node with `display: table-row-group`. This yields a `TableRowGroupFlow`
     /// with possibly other `TableRowFlow`s underneath it.
     fn build_flow_for_table_rowgroup(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult {
-        let box_ = Fragment::new_from_specific_info(node, TableRowFragment);
-        let flow = box TableRowGroupFlow::from_node_and_box(node, box_) as Box<Flow:Share>;
+        let fragment = Fragment::new_from_specific_info(node, TableRowFragment);
+        let flow = box TableRowGroupFlow::from_node_and_fragment(node, fragment) as Box<Flow:Share>;
         self.build_flow_using_children(flow, node)
     }
 
     /// Builds a flow for a node with `display: table-row`. This yields a `TableRowFlow` with
     /// possibly other `TableCellFlow`s underneath it.
     fn build_flow_for_table_row(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult {
-        let box_ = Fragment::new_from_specific_info(node, TableRowFragment);
-        let flow = box TableRowFlow::from_node_and_box(node, box_) as Box<Flow:Share>;
+        let fragment = Fragment::new_from_specific_info(node, TableRowFragment);
+        let flow = box TableRowFlow::from_node_and_fragment(node, fragment) as Box<Flow:Share>;
         self.build_flow_using_children(flow, node)
     }
 
     /// Builds a flow for a node with `display: table-cell`. This yields a `TableCellFlow` with
     /// possibly other `BlockFlow`s or `InlineFlow`s underneath it.
     fn build_flow_for_table_cell(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult {
-        let box_ = Fragment::new_from_specific_info(node, TableCellFragment);
-        let flow = box TableCellFlow::from_node_and_box(node, box_) as Box<Flow:Share>;
+        let fragment = Fragment::new_from_specific_info(node, TableCellFragment);
+        let flow = box TableCellFlow::from_node_and_fragment(node, fragment) as Box<Flow:Share>;
         self.build_flow_using_children(flow, node)
     }
 
-    /// Creates a box for a node with `display: table-column`.
-    fn build_boxes_for_table_column(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult {
-        // CSS 2.1 § 17.2.1. Treat all child boxes of a `table-column` as `display: none`.
+    /// Creates a fragment for a node with `display: table-column`.
+    fn build_fragments_for_table_column(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult {
+        // CSS 2.1 § 17.2.1. Treat all child fragments of a `table-column` as `display: none`.
         for kid in node.children() {
             kid.set_flow_construction_result(NoConstructionResult)
         }
@@ -799,25 +800,25 @@ impl<'a> FlowConstructor<'a> {
     /// Builds a flow for a node with `display: table-column-group`.
     /// This yields a `TableColGroupFlow`.
     fn build_flow_for_table_colgroup(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult {
-        let box_ = Fragment::new_from_specific_info(node,
+        let fragment = Fragment::new_from_specific_info(node,
                                                TableColumnFragment(TableColumnFragmentInfo::new(node)));
-        let mut col_boxes = vec!();
+        let mut col_fragments = vec!();
         for kid in node.children() {
-            // CSS 2.1 § 17.2.1. Treat all non-column child boxes of `table-column-group`
+            // CSS 2.1 § 17.2.1. Treat all non-column child fragments of `table-column-group`
             // as `display: none`.
             match kid.swap_out_construction_result() {
-                ConstructionItemConstructionResult(TableColumnFragmentConstructionItem(box_)) => {
-                    col_boxes.push(box_);
+                ConstructionItemConstructionResult(TableColumnFragmentConstructionItem(fragment)) => {
+                    col_fragments.push(fragment);
                 }
                 _ => {}
             }
         }
-        if col_boxes.is_empty() {
+        if col_fragments.is_empty() {
             debug!("add TableColumnFragment for empty colgroup");
             let specific = TableColumnFragment(TableColumnFragmentInfo::new(node));
-            col_boxes.push(Fragment::new_from_specific_info(node, specific));
+            col_fragments.push(Fragment::new_from_specific_info(node, specific));
         }
-        let mut flow = box TableColGroupFlow::from_node_and_boxes(node, box_, col_boxes) as Box<Flow:Share>;
+        let mut flow = box TableColGroupFlow::from_node_and_fragments(node, fragment, col_fragments) as Box<Flow:Share>;
         flow.finish(self.layout_context);
 
         FlowConstructionResult(flow, Descendants::new())
@@ -886,9 +887,9 @@ impl<'a> PostorderNodeMutTraversal for FlowConstructor<'a> {
                 node.set_flow_construction_result(self.build_flow_for_block(node))
             }
 
-            // Inline items contribute inline box construction results.
+            // Inline items contribute inline fragment construction results.
             (display::inline, float::none, _) => {
-                let construction_result = self.build_boxes_for_inline(node);
+                let construction_result = self.build_fragments_for_inline(node);
                 node.set_flow_construction_result(construction_result)
             }
 
@@ -906,7 +907,7 @@ impl<'a> PostorderNodeMutTraversal for FlowConstructor<'a> {
 
             // Table items contribute table flow construction results.
             (display::table_column, _, _) => {
-                let construction_result = self.build_boxes_for_table_column(node);
+                let construction_result = self.build_fragments_for_table_column(node);
                 node.set_flow_construction_result(construction_result)
             }
 
@@ -1084,57 +1085,57 @@ impl<'ln> ObjectElement for ThreadSafeLayoutNode<'ln> {
     }
 }
 
-/// Strips ignorable whitespace from the start of a list of boxes.
-fn strip_ignorable_whitespace_from_start(boxes: &mut InlineFragments) {
-    if boxes.len() == 0 {
+/// Strips ignorable whitespace from the start of a list of fragments.
+fn strip_ignorable_whitespace_from_start(fragments: &mut InlineFragments) {
+    if fragments.len() == 0 {
         return
     }
 
     let InlineFragments {
-        boxes: old_boxes,
+        fragments: old_fragments,
         map: mut map
-    } = mem::replace(boxes, InlineFragments::new());
+    } = mem::replace(fragments, InlineFragments::new());
 
     // FIXME(#2264, pcwalton): This is slow because vector shift is broken. :(
     let mut found_nonwhitespace = false;
-    let mut new_boxes = Vec::new();
-    for fragment in old_boxes.iter() {
+    let mut new_fragments = Vec::new();
+    for fragment in old_fragments.iter() {
         if !found_nonwhitespace && fragment.is_whitespace_only() {
             debug!("stripping ignorable whitespace from start");
             continue
         }
 
         found_nonwhitespace = true;
-        new_boxes.push(fragment.clone())
+        new_fragments.push(fragment.clone())
     }
 
-    map.fixup(old_boxes.as_slice(), new_boxes.as_slice());
-    *boxes = InlineFragments {
-        boxes: new_boxes,
+    map.fixup(old_fragments.as_slice(), new_fragments.as_slice());
+    *fragments = InlineFragments {
+        fragments: new_fragments,
         map: map,
     }
 }
 
-/// Strips ignorable whitespace from the end of a list of boxes.
-fn strip_ignorable_whitespace_from_end(boxes: &mut InlineFragments) {
-    if boxes.len() == 0 {
+/// Strips ignorable whitespace from the end of a list of fragments.
+fn strip_ignorable_whitespace_from_end(fragments: &mut InlineFragments) {
+    if fragments.len() == 0 {
         return
     }
 
     let InlineFragments {
-        boxes: old_boxes,
+        fragments: old_fragments,
         map: mut map
-    } = mem::replace(boxes, InlineFragments::new());
+    } = mem::replace(fragments, InlineFragments::new());
 
-    let mut new_boxes = old_boxes.clone();
-    while new_boxes.len() > 0 && new_boxes.as_slice().last().get_ref().is_whitespace_only() {
+    let mut new_fragments = old_fragments.clone();
+    while new_fragments.len() > 0 && new_fragments.as_slice().last().get_ref().is_whitespace_only() {
         debug!("stripping ignorable whitespace from end");
-        drop(new_boxes.pop());
+        drop(new_fragments.pop());
     }
 
-    map.fixup(old_boxes.as_slice(), new_boxes.as_slice());
-    *boxes = InlineFragments {
-        boxes: new_boxes,
+    map.fixup(old_fragments.as_slice(), new_fragments.as_slice());
+    *fragments = InlineFragments {
+        fragments: new_fragments,
         map: map,
     }
 }
diff --git a/src/components/main/layout/extra.rs b/src/components/main/layout/extra.rs
index ef8878d1477..b6e57ad252f 100644
--- a/src/components/main/layout/extra.rs
+++ b/src/components/main/layout/extra.rs
@@ -18,7 +18,7 @@ pub trait LayoutAuxMethods {
 impl<'ln> LayoutAuxMethods for LayoutNode<'ln> {
     /// Resets layout data and styles for the node.
     ///
-    /// FIXME(pcwalton): Do this as part of box building instead of in a traversal.
+    /// FIXME(pcwalton): Do this as part of fragment building instead of in a traversal.
     fn initialize_layout_data(&self, chan: LayoutChan) {
         let mut layout_data_ref = self.mutate_layout_data();
         match *layout_data_ref {
@@ -35,7 +35,7 @@ impl<'ln> LayoutAuxMethods for LayoutNode<'ln> {
 
     /// Resets layout data and styles for a Node tree.
         ///
-    /// FIXME(pcwalton): Do this as part of box building instead of in a traversal.
+    /// FIXME(pcwalton): Do this as part of fragment building instead of in a traversal.
     fn initialize_style_for_subtree(&self, chan: LayoutChan) {
         for n in self.traverse_preorder() {
             n.initialize_layout_data(chan.clone());
diff --git a/src/components/main/layout/floats.rs b/src/components/main/layout/floats.rs
index 9eaed7f0cef..007c508029e 100644
--- a/src/components/main/layout/floats.rs
+++ b/src/components/main/layout/floats.rs
@@ -320,7 +320,7 @@ impl Floats {
         max_height.map(|h| h + self.offset.y)
     }
 
-    /// Given placement information, finds the closest place a box can be positioned without
+    /// Given placement information, finds the closest place a fragment can be positioned without
     /// colliding with any floats.
     pub fn place_between_floats(&self, info: &PlacementInfo) -> Rect<Au> {
         debug!("place_between_floats: Placing object with width {} and height {}",
diff --git a/src/components/main/layout/flow.rs b/src/components/main/layout/flow.rs
index 0e3538063f2..2781a856d87 100644
--- a/src/components/main/layout/flow.rs
+++ b/src/components/main/layout/flow.rs
@@ -8,8 +8,8 @@
 /// inline and block layout.
 ///
 /// Flows are interior nodes in the layout tree and correspond closely to *flow contexts* in the
-/// CSS specification. Flows are responsible for positioning their child flow contexts and boxes.
-/// Flows have purpose-specific fields, such as auxiliary line box structs, out-of-flow child
+/// CSS specification. Flows are responsible for positioning their child flow contexts and fragments.
+/// Flows have purpose-specific fields, such as auxiliary line fragment structs, out-of-flow child
 /// lists, and so on.
 ///
 /// Currently, the important types of flows are:
@@ -21,7 +21,7 @@
 ///   the viewport.
 ///
 /// * `InlineFlow`: A flow that establishes an inline context. It has a flat list of child
-///   boxes/flows that are subject to inline layout and line breaking and structs to represent
+///   fragments/flows that are subject to inline layout and line breaking and structs to represent
 ///   line breaks and mapping to CSS boxes, for the purpose of handling `getClientRects()` and
 ///   similar methods.
 
@@ -844,12 +844,12 @@ impl<'a> ImmutableFlowUtils for &'a Flow {
     fn generate_missing_child_flow(self, node: &ThreadSafeLayoutNode) -> Box<Flow:Share> {
         match self.class() {
             TableFlowClass | TableRowGroupFlowClass => {
-                let box_ = Fragment::new_anonymous_table_box(node, TableRowFragment);
-                box TableRowFlow::from_node_and_box(node, box_) as Box<Flow:Share>
+                let fragment = Fragment::new_anonymous_table_fragment(node, TableRowFragment);
+                box TableRowFlow::from_node_and_fragment(node, fragment) as Box<Flow:Share>
             },
             TableRowFlowClass => {
-                let box_ = Fragment::new_anonymous_table_box(node, TableCellFragment);
-                box TableCellFlow::from_node_and_box(node, box_) as Box<Flow:Share>
+                let fragment = Fragment::new_anonymous_table_fragment(node, TableCellFragment);
+                box TableCellFlow::from_node_and_fragment(node, fragment) as Box<Flow:Share>
             },
             _ => {
                 fail!("no need to generate a missing child")
@@ -869,8 +869,8 @@ impl<'a> ImmutableFlowUtils for &'a Flow {
 
     /// Return true if this flow is a Block Container.
     ///
-    /// Except for table boxes and replaced elements, block-level boxes (`BlockFlow`) are
-    /// also block container boxes.
+    /// Except for table fragments and replaced elements, block-level fragments (`BlockFlow`) are
+    /// also block container fragments.
     /// Non-replaced inline blocks and non-replaced table cells are also block
     /// containers.
     fn is_block_container(self) -> bool {
@@ -1065,7 +1065,7 @@ impl MutableOwnedFlowUtils for Box<Flow:Share> {
         let _ = base.parallel.children_and_absolute_descendant_count.fetch_add(1, Relaxed);
     }
 
-    /// Finishes a flow. Once a flow is finished, no more child flows or boxes may be added to it.
+    /// Finishes a flow. Once a flow is finished, no more child flows or fragments may be added to it.
     /// This will normally run the bubble-widths (minimum and preferred -- i.e. intrinsic -- width)
     /// calculation, unless the global `bubble_widths_separately` flag is on.
     ///
diff --git a/src/components/main/layout/inline.rs b/src/components/main/layout/inline.rs
index a92047bec8d..df9ec106a65 100644
--- a/src/components/main/layout/inline.rs
+++ b/src/components/main/layout/inline.rs
@@ -33,39 +33,39 @@ use style::computed_values::{text_align, vertical_align, white_space};
 use style::ComputedValues;
 use sync::Arc;
 
-/// Lineboxes are represented as offsets into the child list, rather than
-/// as an object that "owns" boxes. Choosing a different set of line
+/// `LineFragment`s are represented as offsets into the child list, rather than
+/// as an object that "owns" fragments. Choosing a different set of line
 /// breaks requires a new list of offsets, and possibly some splitting and
 /// merging of TextFragments.
 ///
-/// A similar list will keep track of the mapping between CSS boxes and
-/// the corresponding boxes in the inline flow.
+/// A similar list will keep track of the mapping between CSS fragments and
+/// the corresponding fragments in the inline flow.
 ///
-/// After line breaks are determined, render boxes in the inline flow may
-/// overlap visually. For example, in the case of nested inline CSS boxes,
+/// After line breaks are determined, render fragments in the inline flow may
+/// overlap visually. For example, in the case of nested inline CSS fragments,
 /// outer inlines must be at least as large as the inner inlines, for
 /// purposes of drawing noninherited things like backgrounds, borders,
 /// outlines.
 ///
 /// N.B. roc has an alternative design where the list instead consists of
-/// things like "start outer box, text, start inner box, text, end inner
-/// box, text, end outer box, text". This seems a little complicated to
+/// things like "start outer fragment, text, start inner fragment, text, end inner
+/// fragment, text, end outer fragment, text". This seems a little complicated to
 /// serve as the starting point, but the current design doesn't make it
 /// hard to try out that alternative.
 ///
-/// Line boxes also contain some metadata used during line breaking. The
+/// Line fragments also contain some metadata used during line breaking. The
 /// green zone is the area that the line can expand to before it collides
 /// with a float or a horizontal wall of the containing block. The top
 /// left corner of the green zone is the same as that of the line, but
 /// the green zone can be taller and wider than the line itself.
-pub struct LineBox {
+pub struct LineFragment {
     pub range: Range<LineIndices>,
     pub bounds: Rect<Au>,
     pub green_zone: Size2D<Au>
 }
 
 int_range_index! {
-    #[doc = "The index of a box fragment in a flattened vector of DOM elements."]
+    #[doc = "The index of a fragment in a flattened vector of DOM elements."]
     struct FragmentIndex(int)
 }
 
@@ -97,8 +97,7 @@ int_range_index! {
 /// ~~~
 #[deriving(Clone, Eq, Ord, TotalEq, TotalOrd, Zero)]
 pub struct LineIndices {
-    /// The index of a box fragment into the flattened vector of DOM
-    /// elements.
+    /// The index of a fragment into the flattened vector of DOM elements.
     ///
     /// For example, given the HTML below:
     ///
@@ -199,22 +198,22 @@ pub fn each_char_index(range: &Range<LineIndices>) -> EachIndex<int, CharIndex>
     range::each_index(range.begin().char_index, range.end().char_index)
 }
 
-struct LineboxScanner {
+struct LineFragmentScanner {
     pub floats: Floats,
-    pub new_boxes: Vec<Fragment>,
+    pub new_fragments: Vec<Fragment>,
     pub work_list: RingBuf<Fragment>,
-    pub pending_line: LineBox,
-    pub lines: Vec<LineBox>,
+    pub pending_line: LineFragment,
+    pub lines: Vec<LineFragment>,
     pub cur_y: Au,
 }
 
-impl LineboxScanner {
-    pub fn new(float_ctx: Floats) -> LineboxScanner {
-        LineboxScanner {
+impl LineFragmentScanner {
+    pub fn new(float_ctx: Floats) -> LineFragmentScanner {
+        LineFragmentScanner {
             floats: float_ctx,
-            new_boxes: Vec::new(),
+            new_fragments: Vec::new(),
             work_list: RingBuf::new(),
-            pending_line: LineBox {
+            pending_line: LineFragment {
                 range: Range::empty(),
                 bounds: Rect(Point2D(Au::new(0), Au::new(0)), Size2D(Au::new(0), Au::new(0))),
                 green_zone: Size2D(Au::new(0), Au::new(0))
@@ -229,14 +228,14 @@ impl LineboxScanner {
     }
 
     fn reset_scanner(&mut self) {
-        debug!("Resetting line box scanner's state for flow.");
+        debug!("Resetting LineFragmentScanner's state for flow.");
         self.lines = Vec::new();
-        self.new_boxes = Vec::new();
+        self.new_fragments = Vec::new();
         self.cur_y = Au(0);
-        self.reset_linebox();
+        self.reset_line_fragment();
     }
 
-    fn reset_linebox(&mut self) {
+    fn reset_line_fragment(&mut self) {
         self.pending_line.range.reset(num::zero(), num::zero());
         self.pending_line.bounds = Rect(Point2D(Au::new(0), self.cur_y), Size2D(Au::new(0), Au::new(0)));
         self.pending_line.green_zone = Size2D(Au::new(0), Au::new(0))
@@ -247,52 +246,52 @@ impl LineboxScanner {
 
         // Swap out temporarily.
         let InlineFragments {
-            boxes: old_boxes,
+            fragments: old_fragments,
             map: mut map
-        } = mem::replace(&mut flow.boxes, InlineFragments::new());
+        } = mem::replace(&mut flow.fragments, InlineFragments::new());
 
-        let mut old_box_iter = old_boxes.iter();
+        let mut old_fragment_iter = old_fragments.iter();
         loop {
-            // acquire the next box to lay out from work list or box list
-            let cur_box = if self.work_list.is_empty() {
-                match old_box_iter.next() {
+            // acquire the next fragment to lay out from work list or fragment list
+            let cur_fragment = if self.work_list.is_empty() {
+                match old_fragment_iter.next() {
                     None => break,
                     Some(fragment) => {
-                        debug!("LineboxScanner: Working with fragment from flow: b{}",
+                        debug!("LineFragmentScanner: Working with fragment from flow: b{}",
                                fragment.debug_id());
                         (*fragment).clone()
                     }
                 }
             } else {
                 let fragment = self.work_list.pop_front().unwrap();
-                debug!("LineboxScanner: Working with box from work list: b{}",
+                debug!("LineFragmentScanner: Working with fragment from work list: b{}",
                        fragment.debug_id());
                 fragment
             };
 
-            let box_was_appended = match cur_box.white_space() {
-                white_space::normal => self.try_append_to_line(cur_box, flow),
-                white_space::pre => self.try_append_to_line_by_new_line(cur_box),
+            let fragment_was_appended = match cur_fragment.white_space() {
+                white_space::normal => self.try_append_to_line(cur_fragment, flow),
+                white_space::pre => self.try_append_to_line_by_new_line(cur_fragment),
             };
 
-            if !box_was_appended {
-                debug!("LineboxScanner: Fragment wasn't appended, because line {:u} was full.",
+            if !fragment_was_appended {
+                debug!("LineFragmentScanner: Fragment wasn't appended, because line {:u} was full.",
                         self.lines.len());
                 self.flush_current_line();
             } else {
-                debug!("LineboxScanner: appended a box to line {:u}", self.lines.len());
+                debug!("LineFragmentScanner: appended a fragment to line {:u}", self.lines.len());
             }
         }
 
         if self.pending_line.range.length() > num::zero() {
-            debug!("LineboxScanner: Partially full linebox {:u} left at end of scanning.",
+            debug!("LineFragmentScanner: Partially full line_fragment {:u} left at end of scanning.",
                     self.lines.len());
             self.flush_current_line();
         }
 
-        map.fixup(old_boxes.as_slice(), self.new_boxes.as_slice());
-        flow.boxes = InlineFragments {
-            boxes: mem::replace(&mut self.new_boxes, Vec::new()),
+        map.fixup(old_fragments.as_slice(), self.new_fragments.as_slice());
+        flow.fragments = InlineFragments {
+            fragments: mem::replace(&mut self.new_fragments, Vec::new()),
             map: map,
         };
 
@@ -300,49 +299,49 @@ impl LineboxScanner {
     }
 
     fn flush_current_line(&mut self) {
-        debug!("LineboxScanner: Flushing line {:u}: {:?}",
+        debug!("LineFragmentScanner: Flushing line {:u}: {:?}",
                self.lines.len(), self.pending_line);
 
         // clear line and add line mapping
-        debug!("LineboxScanner: Saving information for flushed line {:u}.", self.lines.len());
+        debug!("LineFragmentScanner: Saving information for flushed line {:u}.", self.lines.len());
         self.lines.push(self.pending_line);
         self.cur_y = self.pending_line.bounds.origin.y + self.pending_line.bounds.size.height;
-        self.reset_linebox();
+        self.reset_line_fragment();
     }
 
-    // FIXME(eatkinson): this assumes that the tallest box in the line determines the line height
+    // FIXME(eatkinson): this assumes that the tallest fragment in the line determines the line height
     // This might not be the case with some weird text fonts.
-    fn new_height_for_line(&self, new_box: &Fragment) -> Au {
-        let box_height = new_box.content_height();
-        if box_height > self.pending_line.bounds.size.height {
-            box_height
+    fn new_height_for_line(&self, new_fragment: &Fragment) -> Au {
+        let fragment_height = new_fragment.content_height();
+        if fragment_height > self.pending_line.bounds.size.height {
+            fragment_height
         } else {
             self.pending_line.bounds.size.height
         }
     }
 
-    /// Computes the position of a line that has only the provided box. Returns the bounding rect
-    /// of the line's green zone (whose origin coincides with the line's origin) and the actual
-    /// width of the first box after splitting.
-    fn initial_line_placement(&self, first_box: &Fragment, ceiling: Au, flow: &mut InlineFlow)
+    /// Computes the position of a line that has only the provided fragment. Returns the bounding
+    /// rect of the line's green zone (whose origin coincides with the line's origin) and the actual
+    /// width of the first fragment after splitting.
+    fn initial_line_placement(&self, first_fragment: &Fragment, ceiling: Au, flow: &mut InlineFlow)
                               -> (Rect<Au>, Au) {
-        debug!("LineboxScanner: Trying to place first box of line {}", self.lines.len());
+        debug!("LineFragmentScanner: Trying to place first fragment of line {}", self.lines.len());
 
-        let first_box_size = first_box.border_box.size;
-        let splittable = first_box.can_split();
-        debug!("LineboxScanner: box size: {}, splittable: {}", first_box_size, splittable);
+        let first_fragment_size = first_fragment.border_box.size;
+        let splittable = first_fragment.can_split();
+        debug!("LineFragmentScanner: fragment size: {}, splittable: {}", first_fragment_size, splittable);
 
-        // Initally, pretend a splittable box has 0 width.
+        // Initally, pretend a splittable fragment has 0 width.
         // We will move it later if it has nonzero width
         // and that causes problems.
         let placement_width = if splittable {
             Au::new(0)
         } else {
-            first_box_size.width
+            first_fragment_size.width
         };
 
         let info = PlacementInfo {
-            size: Size2D(placement_width, first_box_size.height),
+            size: Size2D(placement_width, first_fragment_size.height),
             ceiling: ceiling,
             max_width: flow.base.position.size.width,
             kind: FloatLeft,
@@ -350,33 +349,33 @@ impl LineboxScanner {
 
         let line_bounds = self.floats.place_between_floats(&info);
 
-        debug!("LineboxScanner: found position for line: {} using placement_info: {:?}",
+        debug!("LineFragmentScanner: found position for line: {} using placement_info: {:?}",
                line_bounds,
                info);
 
-        // Simple case: if the box fits, then we can stop here
-        if line_bounds.size.width > first_box_size.width {
-            debug!("LineboxScanner: case=box fits");
-            return (line_bounds, first_box_size.width);
+        // Simple case: if the fragment fits, then we can stop here
+        if line_bounds.size.width > first_fragment_size.width {
+            debug!("LineFragmentScanner: case=fragment fits");
+            return (line_bounds, first_fragment_size.width);
         }
 
-        // If not, but we can't split the box, then we'll place
+        // If not, but we can't split the fragment, then we'll place
         // the line here and it will overflow.
         if !splittable {
-            debug!("LineboxScanner: case=line doesn't fit, but is unsplittable");
-            return (line_bounds, first_box_size.width);
+            debug!("LineFragmentScanner: case=line doesn't fit, but is unsplittable");
+            return (line_bounds, first_fragment_size.width);
         }
 
-        debug!("LineboxScanner: used to call split_to_width here");
-        return (line_bounds, first_box_size.width);
+        debug!("LineFragmentScanner: used to call split_to_width here");
+        return (line_bounds, first_fragment_size.width);
     }
 
-    /// Performs float collision avoidance. This is called when adding a box is going to increase
+    /// Performs float collision avoidance. This is called when adding a fragment is going to increase
     /// the height, and because of that we will collide with some floats.
     ///
     /// We have two options here:
     /// 1) Move the entire line so that it doesn't collide any more.
-    /// 2) Break the line and put the new box on the next line.
+    /// 2) Break the line and put the new fragment on the next line.
     ///
     /// The problem with option 1 is that we might move the line and then wind up breaking anyway,
     /// which violates the standard.
@@ -386,93 +385,93 @@ impl LineboxScanner {
     ///
     /// Returns false if and only if we should break the line.
     fn avoid_floats(&mut self,
-                    in_box: Fragment,
+                    in_fragment: Fragment,
                     flow: &mut InlineFlow,
                     new_height: Au,
                     line_is_empty: bool)
                     -> bool {
-        debug!("LineboxScanner: entering float collision avoider!");
+        debug!("LineFragmentScanner: entering float collision avoider!");
 
         // First predict where the next line is going to be.
         let this_line_y = self.pending_line.bounds.origin.y;
-        let (next_line, first_box_width) = self.initial_line_placement(&in_box, this_line_y, flow);
+        let (next_line, first_fragment_width) = self.initial_line_placement(&in_fragment, this_line_y, flow);
         let next_green_zone = next_line.size;
 
-        let new_width = self.pending_line.bounds.size.width + first_box_width;
+        let new_width = self.pending_line.bounds.size.width + first_fragment_width;
 
         // Now, see if everything can fit at the new location.
         if next_green_zone.width >= new_width && next_green_zone.height >= new_height {
-            debug!("LineboxScanner: case=adding box collides vertically with floats: moving line");
+            debug!("LineFragmentScanner: case=adding fragment collides vertically with floats: moving line");
 
             self.pending_line.bounds.origin = next_line.origin;
             self.pending_line.green_zone = next_green_zone;
 
             assert!(!line_is_empty, "Non-terminating line breaking");
-            self.work_list.push_front(in_box);
+            self.work_list.push_front(in_fragment);
             return true
         }
 
-        debug!("LineboxScanner: case=adding box collides vertically with floats: breaking line");
-        self.work_list.push_front(in_box);
+        debug!("LineFragmentScanner: case=adding fragment collides vertically with floats: breaking line");
+        self.work_list.push_front(in_fragment);
         false
     }
 
-    fn try_append_to_line_by_new_line(&mut self, in_box: Fragment) -> bool {
-        if in_box.new_line_pos.len() == 0 {
-                debug!("LineboxScanner: Did not find a new-line character, so pushing the box to \
+    fn try_append_to_line_by_new_line(&mut self, in_fragment: Fragment) -> bool {
+        if in_fragment.new_line_pos.len() == 0 {
+                debug!("LineFragmentScanner: Did not find a new-line character, so pushing the fragment to \
                        the line without splitting.");
-            self.push_box_to_line(in_box);
+            self.push_fragment_to_line(in_fragment);
             true
         } else {
-            debug!("LineboxScanner: Found a new-line character, so splitting theline.");
-            match in_box.find_split_info_by_new_line() {
+            debug!("LineFragmentScanner: Found a new-line character, so splitting theline.");
+            match in_fragment.find_split_info_by_new_line() {
                 Some((left, right, run)) => {
-                    // TODO(bjz): Remove box splitting
-                    let split_box = |split: SplitInfo| {
+                    // TODO(bjz): Remove fragment splitting
+                    let split_fragment = |split: SplitInfo| {
                         let info = ScannedTextFragmentInfo::new(run.clone(), split.range);
                         let specific = ScannedTextFragment(info);
-                        let size = Size2D(split.width, in_box.border_box.size.height);
-                        in_box.transform(size, specific)
+                        let size = Size2D(split.width, in_fragment.border_box.size.height);
+                        in_fragment.transform(size, specific)
                     };
 
-                    debug!("LineboxScanner: Pushing the box to the left of the new-line character \
+                    debug!("LineFragmentScanner: Pushing the fragment to the left of the new-line character \
                            to the line.");
-                    let mut left = split_box(left);
+                    let mut left = split_fragment(left);
                     left.new_line_pos = vec!();
-                    self.push_box_to_line(left);
+                    self.push_fragment_to_line(left);
 
                     for right in right.move_iter() {
-                        debug!("LineboxScanner: Deferring the box to the right of the new-line \
+                        debug!("LineFragmentScanner: Deferring the fragment to the right of the new-line \
                                character to the line.");
-                        let mut right = split_box(right);
-                        right.new_line_pos = in_box.new_line_pos.clone();
+                        let mut right = split_fragment(right);
+                        right.new_line_pos = in_fragment.new_line_pos.clone();
                         self.work_list.push_front(right);
                     }
                 },
                 None => {
-                    error!("LineboxScanner: This split case makes no sense!")
+                    error!("LineFragmentScanner: This split case makes no sense!")
                 },
             }
             false
         }
     }
 
-    /// Tries to append the given box to the line, splitting it if necessary. Returns false only if
+    /// Tries to append the given fragment to the line, splitting it if necessary. Returns false only if
     /// we should break the line.
-    fn try_append_to_line(&mut self, in_box: Fragment, flow: &mut InlineFlow) -> bool {
+    fn try_append_to_line(&mut self, in_fragment: Fragment, flow: &mut InlineFlow) -> bool {
         let line_is_empty = self.pending_line.range.length() == num::zero();
         if line_is_empty {
-            let (line_bounds, _) = self.initial_line_placement(&in_box, self.cur_y, flow);
+            let (line_bounds, _) = self.initial_line_placement(&in_fragment, self.cur_y, flow);
             self.pending_line.bounds.origin = line_bounds.origin;
             self.pending_line.green_zone = line_bounds.size;
         }
 
-        debug!("LineboxScanner: Trying to append box to line {:u} (box size: {}, green zone: \
+        debug!("LineFragmentScanner: Trying to append fragment to line {:u} (fragment size: {}, green zone: \
                 {}): {}",
                self.lines.len(),
-               in_box.border_box.size,
+               in_fragment.border_box.size,
                self.pending_line.green_zone,
-               in_box);
+               in_fragment);
 
         let green_zone = self.pending_line.green_zone;
 
@@ -480,87 +479,87 @@ impl LineboxScanner {
         // `green_zone.height < self.pending_line.bounds.size.height`, then we committed a line
         // that overlaps with floats.
 
-        let new_height = self.new_height_for_line(&in_box);
+        let new_height = self.new_height_for_line(&in_fragment);
         if new_height > green_zone.height {
             // Uh-oh. Float collision imminent. Enter the float collision avoider
-            return self.avoid_floats(in_box, flow, new_height, line_is_empty)
+            return self.avoid_floats(in_fragment, flow, new_height, line_is_empty)
         }
 
         // If we're not going to overflow the green zone vertically, we might still do so
-        // horizontally. We'll try to place the whole box on this line and break somewhere if it
+        // horizontally. We'll try to place the whole fragment on this line and break somewhere if it
         // doesn't fit.
 
-        let new_width = self.pending_line.bounds.size.width + in_box.border_box.size.width;
+        let new_width = self.pending_line.bounds.size.width + in_fragment.border_box.size.width;
         if new_width <= green_zone.width {
-            debug!("LineboxScanner: case=box fits without splitting");
-            self.push_box_to_line(in_box);
+            debug!("LineFragmentScanner: case=fragment fits without splitting");
+            self.push_fragment_to_line(in_fragment);
             return true
         }
 
-        if !in_box.can_split() {
+        if !in_fragment.can_split() {
             // TODO(eatkinson, issue #224): Signal that horizontal overflow happened?
             if line_is_empty {
-                debug!("LineboxScanner: case=box can't split and line {:u} is empty, so \
+                debug!("LineFragmentScanner: case=fragment can't split and line {:u} is empty, so \
                         overflowing.",
                         self.lines.len());
-                self.push_box_to_line(in_box);
+                self.push_fragment_to_line(in_fragment);
                 return true
             }
         }
 
         let available_width = green_zone.width - self.pending_line.bounds.size.width;
-        let split = in_box.find_split_info_for_width(CharIndex(0), available_width, line_is_empty);
+        let split = in_fragment.find_split_info_for_width(CharIndex(0), available_width, line_is_empty);
         match split.map(|(left, right, run)| {
-            // TODO(bjz): Remove box splitting
-            let split_box = |split: SplitInfo| {
+            // TODO(bjz): Remove fragment splitting
+            let split_fragment = |split: SplitInfo| {
                 let info = ScannedTextFragmentInfo::new(run.clone(), split.range);
                 let specific = ScannedTextFragment(info);
-                let size = Size2D(split.width, in_box.border_box.size.height);
-                in_box.transform(size, specific)
+                let size = Size2D(split.width, in_fragment.border_box.size.height);
+                in_fragment.transform(size, specific)
             };
 
-            (left.map(|x| { debug!("LineboxScanner: Left split {}", x); split_box(x) }),
-             right.map(|x| { debug!("LineboxScanner: Right split {}", x); split_box(x) }))
+            (left.map(|x| { debug!("LineFragmentScanner: Left split {}", x); split_fragment(x) }),
+             right.map(|x| { debug!("LineFragmentScanner: Right split {}", x); split_fragment(x) }))
         }) {
             None => {
-                debug!("LineboxScanner: Tried to split unsplittable render box! Deferring to next \
-                       line. {}", in_box);
-                self.work_list.push_front(in_box);
+                debug!("LineFragmentScanner: Tried to split unsplittable render fragment! Deferring to next \
+                       line. {}", in_fragment);
+                self.work_list.push_front(in_fragment);
                 false
             },
-            Some((Some(left_box), Some(right_box))) => {
-                debug!("LineboxScanner: Line break found! Pushing left box to line and deferring \
-                       right box to next line.");
-                self.push_box_to_line(left_box);
-                self.work_list.push_front(right_box);
+            Some((Some(left_fragment), Some(right_fragment))) => {
+                debug!("LineFragmentScanner: Line break found! Pushing left fragment to line and deferring \
+                       right fragment to next line.");
+                self.push_fragment_to_line(left_fragment);
+                self.work_list.push_front(right_fragment);
                 true
             },
-            Some((Some(left_box), None)) => {
-                debug!("LineboxScanner: Pushing left box to line.");
-                self.push_box_to_line(left_box);
+            Some((Some(left_fragment), None)) => {
+                debug!("LineFragmentScanner: Pushing left fragment to line.");
+                self.push_fragment_to_line(left_fragment);
                 true
             },
-            Some((None, Some(right_box))) => {
-                debug!("LineboxScanner: Pushing right box to line.");
-                self.push_box_to_line(right_box);
+            Some((None, Some(right_fragment))) => {
+                debug!("LineFragmentScanner: Pushing right fragment to line.");
+                self.push_fragment_to_line(right_fragment);
                 true
             },
             Some((None, None)) => {
-                error!("LineboxScanner: This split case makes no sense!");
+                error!("LineFragmentScanner: This split case makes no sense!");
                 true
             },
         }
     }
 
     // An unconditional push
-    fn push_box_to_line(&mut self, box_: Fragment) {
-        debug!("LineboxScanner: Pushing box {} to line {:u}", box_.debug_id(), self.lines.len());
+    fn push_fragment_to_line(&mut self, fragment: Fragment) {
+        debug!("LineFragmentScanner: Pushing fragment {} to line {:u}", fragment.debug_id(), self.lines.len());
 
         if self.pending_line.range.length() == num::zero() {
-            assert!(self.new_boxes.len() <= (u16::MAX as uint));
+            assert!(self.new_fragments.len() <= (u16::MAX as uint));
             self.pending_line.range.reset(
                 LineIndices {
-                    fragment_index: FragmentIndex(self.new_boxes.len() as int),
+                    fragment_index: FragmentIndex(self.new_fragments.len() as int),
                     char_index: CharIndex(0) /* unused for now */,
                 },
                 num::zero()
@@ -571,14 +570,14 @@ impl LineboxScanner {
             char_index: CharIndex(0) /* unused for now */ ,
         });
         self.pending_line.bounds.size.width = self.pending_line.bounds.size.width +
-            box_.border_box.size.width;
+            fragment.border_box.size.width;
         self.pending_line.bounds.size.height = Au::max(self.pending_line.bounds.size.height,
-                                                       box_.border_box.size.height);
-        self.new_boxes.push(box_);
+                                                       fragment.border_box.size.height);
+        self.new_fragments.push(fragment);
     }
 }
 
-/// Iterator over boxes.
+/// Iterator over fragments.
 pub struct FragmentIterator<'a> {
     iter: Enumerate<Items<'a,Fragment>>,
     map: &'a InlineFragmentMap,
@@ -597,7 +596,7 @@ impl<'a> Iterator<(&'a Fragment, InlineFragmentContext<'a>)> for FragmentIterato
     }
 }
 
-/// Mutable iterator over boxes.
+/// Mutable iterator over fragments.
 pub struct MutFragmentIterator<'a> {
     iter: Enumerate<MutItems<'a,Fragment>>,
     map: &'a InlineFragmentMap,
@@ -616,75 +615,75 @@ impl<'a> Iterator<(&'a mut Fragment, InlineFragmentContext<'a>)> for MutFragment
     }
 }
 
-/// Represents a list of inline boxes, including element ranges.
+/// Represents a list of inline fragments, including element ranges.
 pub struct InlineFragments {
-    /// The boxes themselves.
-    pub boxes: Vec<Fragment>,
-    /// Tracks the elements that made up the boxes above.
+    /// The fragments themselves.
+    pub fragments: Vec<Fragment>,
+    /// Tracks the elements that made up the fragments above.
     pub map: InlineFragmentMap,
 }
 
 impl InlineFragments {
-    /// Creates an empty set of inline boxes.
+    /// Creates an empty set of inline fragments.
     pub fn new() -> InlineFragments {
         InlineFragments {
-            boxes: Vec::new(),
+            fragments: Vec::new(),
             map: InlineFragmentMap::new(),
         }
     }
 
-    /// Returns the number of inline boxes.
+    /// Returns the number of inline fragments.
     pub fn len(&self) -> uint {
-        self.boxes.len()
+        self.fragments.len()
     }
 
-    /// Returns true if this list contains no boxes and false if it contains at least one box.
+    /// Returns true if this list contains no fragments and false if it contains at least one fragment.
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
-    /// Pushes a new inline box.
+    /// Pushes a new inline fragment.
     pub fn push(&mut self, fragment: Fragment, style: Arc<ComputedValues>) {
-        self.map.push(style, Range::new(FragmentIndex(self.boxes.len() as int), FragmentIndex(1)));
-        self.boxes.push(fragment)
+        self.map.push(style, Range::new(FragmentIndex(self.fragments.len() as int), FragmentIndex(1)));
+        self.fragments.push(fragment)
     }
 
-    /// Merges another set of inline boxes with this one.
+    /// Merges another set of inline fragments with this one.
     pub fn push_all(&mut self, other: InlineFragments) {
         let InlineFragments {
-            boxes: other_boxes,
+            fragments: other_fragments,
             map: other_map
         } = other;
-        let adjustment = FragmentIndex(self.boxes.len() as int);
+        let adjustment = FragmentIndex(self.fragments.len() as int);
         self.map.push_all(other_map, adjustment);
-        self.boxes.push_all_move(other_boxes);
+        self.fragments.push_all_move(other_fragments);
     }
 
-    /// Returns an iterator that iterates over all boxes along with the appropriate context.
+    /// Returns an iterator that iterates over all fragments along with the appropriate context.
     pub fn iter<'a>(&'a self) -> FragmentIterator<'a> {
         FragmentIterator {
-            iter: self.boxes.as_slice().iter().enumerate(),
+            iter: self.fragments.as_slice().iter().enumerate(),
             map: &self.map,
         }
     }
 
-    /// Returns an iterator that iterates over all boxes along with the appropriate context and
-    /// allows those boxes to be mutated.
+    /// Returns an iterator that iterates over all fragments along with the appropriate context and
+    /// allows those fragments to be mutated.
     pub fn mut_iter<'a>(&'a mut self) -> MutFragmentIterator<'a> {
         MutFragmentIterator {
-            iter: self.boxes.as_mut_slice().mut_iter().enumerate(),
+            iter: self.fragments.as_mut_slice().mut_iter().enumerate(),
             map: &self.map,
         }
     }
 
-    /// A convenience function to return the box at a given index.
+    /// A convenience function to return the fragment at a given index.
     pub fn get<'a>(&'a self, index: uint) -> &'a Fragment {
-        self.boxes.get(index)
+        self.fragments.get(index)
     }
 
-    /// A convenience function to return a mutable reference to the box at a given index.
+    /// A convenience function to return a mutable reference to the fragment at a given index.
     pub fn get_mut<'a>(&'a mut self, index: uint) -> &'a mut Fragment {
-        self.boxes.get_mut(index)
+        self.fragments.get_mut(index)
     }
 }
 
@@ -694,12 +693,12 @@ pub struct InlineFlow {
     pub base: BaseFlow,
 
     /// A vector of all inline fragments. Several fragments may correspond to one node/element.
-    pub boxes: InlineFragments,
+    pub fragments: InlineFragments,
 
-    /// A vector of ranges into boxes that represents line positions. These ranges are disjoint and
+    /// A vector of ranges into fragments that represents line positions. These ranges are disjoint and
     /// are the result of inline layout. This also includes some metadata used for positioning
     /// lines.
-    pub lines: Vec<LineBox>,
+    pub lines: Vec<LineFragment>,
 
     /// The minimum height above the baseline for each line, as specified by the line height and
     /// font style.
@@ -711,10 +710,10 @@ pub struct InlineFlow {
 }
 
 impl InlineFlow {
-    pub fn from_boxes(node: ThreadSafeLayoutNode, boxes: InlineFragments) -> InlineFlow {
+    pub fn from_fragments(node: ThreadSafeLayoutNode, fragments: InlineFragments) -> InlineFlow {
         InlineFlow {
             base: BaseFlow::new(node),
-            boxes: boxes,
+            fragments: fragments,
             lines: Vec::new(),
             minimum_height_above_baseline: Au(0),
             minimum_depth_below_baseline: Au(0),
@@ -727,11 +726,11 @@ impl InlineFlow {
             return
         }
 
-        // TODO(#228): Once we form line boxes and have their cached bounds, we can be smarter and
+        // TODO(#228): Once we form line fragments and have their cached bounds, we can be smarter and
         // not recurse on a line if nothing in it can intersect the dirty region.
-        debug!("Flow: building display list for {:u} inline boxes", self.boxes.len());
+        debug!("Flow: building display list for {:u} inline fragments", self.fragments.len());
 
-        for (fragment, context) in self.boxes.mut_iter() {
+        for (fragment, context) in self.fragments.mut_iter() {
             let rel_offset = fragment.relative_position(&self.base
                                                              .absolute_position_info
                                                              .relative_containing_block_size,
@@ -744,7 +743,7 @@ impl InlineFlow {
         }
 
         // TODO(#225): Should `inline-block` elements have flows as children of the inline flow or
-        // should the flow be nested inside the box somehow?
+        // should the flow be nested inside the fragment somehow?
 
         // For now, don't traverse the subtree rooted here.
     }
@@ -784,17 +783,17 @@ impl InlineFlow {
                 (-super_offset - ascent, false)
             },
             vertical_align::text_top => {
-                let box_height = *height_above_baseline + *depth_below_baseline;
+                let fragment_height = *height_above_baseline + *depth_below_baseline;
                 let prev_depth_below_baseline = *depth_below_baseline;
                 *height_above_baseline = parent_text_top;
-                *depth_below_baseline = box_height - *height_above_baseline;
+                *depth_below_baseline = fragment_height - *height_above_baseline;
                 (*depth_below_baseline - prev_depth_below_baseline - ascent, false)
             },
             vertical_align::text_bottom => {
-                let box_height = *height_above_baseline + *depth_below_baseline;
+                let fragment_height = *height_above_baseline + *depth_below_baseline;
                 let prev_depth_below_baseline = *depth_below_baseline;
                 *depth_below_baseline = parent_text_bottom;
-                *height_above_baseline = box_height - *depth_below_baseline;
+                *height_above_baseline = fragment_height - *depth_below_baseline;
                 (*depth_below_baseline - prev_depth_below_baseline - ascent, false)
             },
             vertical_align::top => {
@@ -821,17 +820,17 @@ impl InlineFlow {
         }
     }
 
-    /// Sets box X positions based on alignment for one line.
-    fn set_horizontal_box_positions(boxes: &mut InlineFragments,
-                                    line: &LineBox,
-                                    linebox_align: text_align::T) {
+    /// Sets fragment X positions based on alignment for one line.
+    fn set_horizontal_fragment_positions(fragments: &mut InlineFragments,
+                                         line: &LineFragment,
+                                         line_fragment_align: text_align::T) {
         // Figure out how much width we have.
         let slack_width = Au::max(Au(0), line.green_zone.width - line.bounds.size.width);
 
-        // Set the box x positions based on that alignment.
+        // Set the fragment x positions based on that alignment.
         let mut offset_x = line.bounds.origin.x;
-        offset_x = offset_x + match linebox_align {
-            // So sorry, but justified text is more complicated than shuffling linebox
+        offset_x = offset_x + match line_fragment_align {
+            // So sorry, but justified text is more complicated than shuffling line_fragment
             // coordinates.
             //
             // TODO(burg, issue #213): Implement `text-align: justify`.
@@ -841,9 +840,9 @@ impl InlineFlow {
         };
 
         for i in each_fragment_index(&line.range) {
-            let box_ = boxes.get_mut(i.to_uint());
-            let size = box_.border_box.size;
-            box_.border_box = Rect(Point2D(offset_x, box_.border_box.origin.y), size);
+            let fragment = fragments.get_mut(i.to_uint());
+            let size = fragment.border_box.size;
+            fragment.border_box = Rect(Point2D(offset_x, fragment.border_box.origin.y), size);
             offset_x = offset_x + size.width;
         }
     }
@@ -883,31 +882,31 @@ impl Flow for InlineFlow {
         }
 
         let mut intrinsic_widths = IntrinsicWidths::new();
-        for (fragment, context) in self.boxes.mut_iter() {
+        for (fragment, context) in self.fragments.mut_iter() {
             debug!("Flow: measuring {}", *fragment);
 
-            let box_intrinsic_widths = fragment.intrinsic_widths(Some(context));
+            let fragment_intrinsic_widths = fragment.intrinsic_widths(Some(context));
             intrinsic_widths.minimum_width = geometry::max(intrinsic_widths.minimum_width,
-                                                           box_intrinsic_widths.minimum_width);
+                                                           fragment_intrinsic_widths.minimum_width);
             intrinsic_widths.preferred_width = geometry::max(intrinsic_widths.preferred_width,
-                                                             box_intrinsic_widths.preferred_width);
+                                                             fragment_intrinsic_widths.preferred_width);
         }
 
         self.base.intrinsic_widths = intrinsic_widths;
     }
 
-    /// Recursively (top-down) determines the actual width of child contexts and boxes. When called
+    /// Recursively (top-down) determines the actual width of child contexts and fragments. When called
     /// on this context, the context has had its width set by the parent context.
     fn assign_widths(&mut self, _: &mut LayoutContext) {
-        // Initialize content box widths if they haven't been initialized already.
+        // Initialize content fragment widths if they haven't been initialized already.
         //
-        // TODO: Combine this with `LineboxScanner`'s walk in the box list, or put this into `Fragment`.
+        // TODO: Combine this with `LineFragmentScanner`'s walk in the fragment list, or put this into `Fragment`.
 
         debug!("InlineFlow::assign_widths: floats in: {:?}", self.base.floats);
 
         {
             let this = &mut *self;
-            for (fragment, context) in this.boxes.mut_iter() {
+            for (fragment, context) in this.fragments.mut_iter() {
                 fragment.assign_replaced_width_if_necessary(self.base.position.size.width,
                                                             Some(context))
             }
@@ -922,57 +921,57 @@ impl Flow for InlineFlow {
         // true.  In that case, set the InlineBlockFragment's width to the
         // shrink-to-fit width, perform inline flow, and set the block
         // flow context's width as the assigned width of the
-        // 'inline-block' box that created this flow before recursing.
+        // 'inline-block' fragment that created this flow before recursing.
     }
 
     /// Calculate and set the height of this flow. See CSS 2.1 § 10.6.1.
     fn assign_height(&mut self, _: &mut LayoutContext) {
         debug!("assign_height_inline: assigning height for flow");
 
-        // Divide the boxes into lines.
+        // Divide the fragments into lines.
         //
         // TODO(#226): Get the CSS `line-height` property from the containing block's style to
-        // determine minimum linebox height.
+        // determine minimum line_fragment height.
         //
         // TODO(#226): Get the CSS `line-height` property from each non-replaced inline element to
-        // determine its height for computing linebox height.
+        // determine its height for computing line_fragment height.
         //
-        // TODO(pcwalton): Cache the linebox scanner?
+        // TODO(pcwalton): Cache the line_fragment scanner?
         debug!("assign_height_inline: floats in: {:?}", self.base.floats);
 
-        // assign height for inline boxes
-        for (fragment, _) in self.boxes.mut_iter() {
+        // assign height for inline fragments
+        for (fragment, _) in self.fragments.mut_iter() {
             fragment.assign_replaced_height_if_necessary();
         }
 
         let scanner_floats = self.base.floats.clone();
-        let mut scanner = LineboxScanner::new(scanner_floats);
+        let mut scanner = LineFragmentScanner::new(scanner_floats);
         scanner.scan_for_lines(self);
 
         // All lines use text alignment of the flow.
         let text_align = self.base.flags.text_align();
 
-        // Now, go through each line and lay out the boxes inside.
+        // Now, go through each line and lay out the fragments inside.
         let mut line_distance_from_flow_top = Au(0);
         for line in self.lines.mut_iter() {
-            // Lay out boxes horizontally.
-            InlineFlow::set_horizontal_box_positions(&mut self.boxes, line, text_align);
+            // Lay out fragments horizontally.
+            InlineFlow::set_horizontal_fragment_positions(&mut self.fragments, line, text_align);
 
-            // Set the top y position of the current line box.
+            // Set the top y position of the current line fragment.
             // `line_height_offset` is updated at the end of the previous loop.
             line.bounds.origin.y = line_distance_from_flow_top;
 
-            // Calculate the distance from the baseline to the top and bottom of the line box.
+            // Calculate the distance from the baseline to the top and bottom of the line fragment.
             let mut largest_height_above_baseline = self.minimum_height_above_baseline;
             let mut largest_depth_below_baseline = self.minimum_depth_below_baseline;
 
-            // Calculate the largest height among boxes with 'top' and 'bottom' values
+            // Calculate the largest height among fragments with 'top' and 'bottom' values
             // respectively.
             let (mut largest_height_for_top_fragments, mut largest_height_for_bottom_fragments) =
                 (Au(0), Au(0));
 
-            for box_i in each_fragment_index(&line.range) {
-                let fragment = self.boxes.boxes.get_mut(box_i.to_uint());
+            for fragment_i in each_fragment_index(&line.range) {
+                let fragment = self.fragments.fragments.get_mut(fragment_i.to_uint());
 
                 let InlineMetrics {
                     height_above_baseline: mut height_above_baseline,
@@ -981,7 +980,7 @@ impl Flow for InlineFlow {
                 } = fragment.inline_metrics();
 
                 // To calculate text-top and text-bottom value when `vertical-align` is involved,
-                // we should find the top and bottom of the content area of the parent box.
+                // we should find the top and bottom of the content area of the parent fragment.
                 // "Content area" is defined in CSS 2.1 § 10.6.1.
                 //
                 // TODO: We should extract em-box info from the font size of the parent and
@@ -999,7 +998,7 @@ impl Flow for InlineFlow {
                 // content area. But for now we assume it's zero.
                 let parent_text_bottom = Au(0);
 
-                // Calculate the final height above the baseline for this box.
+                // Calculate the final height above the baseline for this fragment.
                 //
                 // The no-update flag decides whether `largest_height_for_top_fragments` and
                 // `largest_height_for_bottom_fragments` are to be updated or not. This will be set
@@ -1029,26 +1028,26 @@ impl Flow for InlineFlow {
                 fragment.border_box.origin.y = distance_from_baseline
             }
 
-            // Calculate the distance from the baseline to the top of the largest box with a
+            // Calculate the distance from the baseline to the top of the largest fragment with a
             // value for `bottom`. Then, if necessary, update `largest_height_above_baseline`.
             largest_height_above_baseline =
                 Au::max(largest_height_above_baseline,
                         largest_height_for_bottom_fragments - largest_depth_below_baseline);
 
-            // Calculate the distance from baseline to the bottom of the largest box with a value
+            // Calculate the distance from baseline to the bottom of the largest fragment with a value
             // for `top`. Then, if necessary, update `largest_depth_below_baseline`.
             largest_depth_below_baseline =
                 Au::max(largest_depth_below_baseline,
                         largest_height_for_top_fragments - largest_height_above_baseline);
 
-            // Now, the distance from the logical top of the line box to the baseline can be
+            // Now, the distance from the logical top of the line fragment to the baseline can be
             // computed as `largest_height_above_baseline`.
             let baseline_distance_from_top = largest_height_above_baseline;
 
             // Compute the final positions in the block direction of each fragment. Recall that
             // `fragment.border_box.origin.y` was set to the distance from the baseline above.
-            for box_i in each_fragment_index(&line.range) {
-                let fragment = self.boxes.get_mut(box_i.to_uint());
+            for fragment_i in each_fragment_index(&line.range) {
+                let fragment = self.fragments.get_mut(fragment_i.to_uint());
                 match fragment.vertical_align() {
                     vertical_align::top => {
                         fragment.border_box.origin.y = fragment.border_box.origin.y +
@@ -1066,7 +1065,7 @@ impl Flow for InlineFlow {
                 }
             }
 
-            // This is used to set the top y position of the next line box in the next loop.
+            // This is used to set the top y position of the next line fragment in the next loop.
             line.bounds.size.height = largest_height_above_baseline + largest_depth_below_baseline;
             line_distance_from_flow_top = line_distance_from_flow_top + line.bounds.size.height;
         } // End of `lines.each` loop.
@@ -1087,7 +1086,7 @@ impl Flow for InlineFlow {
 impl fmt::Show for InlineFlow {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         try!(write!(f.buf, "InlineFlow"));
-        for (i, (fragment, _)) in self.boxes.iter().enumerate() {
+        for (i, (fragment, _)) in self.fragments.iter().enumerate() {
             if i == 0 {
                 try!(write!(f.buf, ": {}", fragment))
             } else {
@@ -1099,7 +1098,7 @@ impl fmt::Show for InlineFlow {
 }
 
 /// Information that inline flows keep about a single nested element. This is used to recover the
-/// DOM structure from the flat box list when it's needed.
+/// DOM structure from the flat fragment list when it's needed.
 pub struct InlineFragmentRange {
     /// The style of the DOM node that this range refers to.
     pub style: Arc<ComputedValues>,
@@ -1166,7 +1165,7 @@ impl<'a> Iterator<&'a InlineFragmentRange> for RangeIterator<'a> {
 }
 
 /// Information that inline flows keep about nested elements. This is used to recover the DOM
-/// structure from the flat box list when it's needed.
+/// structure from the flat fragment list when it's needed.
 pub struct InlineFragmentMap {
     list: Vec<InlineFragmentRange>,
 }
@@ -1207,7 +1206,7 @@ impl InlineFragmentMap {
         &mut self.list.as_mut_slice()[index.to_uint()]
     }
 
-    /// Iterates over all ranges that contain the box with the given index, outermost first.
+    /// Iterates over all ranges that contain the fragment with the given index, outermost first.
     #[inline(always)]
     fn ranges_for_index<'a>(&'a self, index: FragmentIndex) -> RangeIterator<'a> {
         RangeIterator {
@@ -1222,10 +1221,10 @@ impl InlineFragmentMap {
     /// DOM has changed, then the flow constructor will need to do more complicated surgery than
     /// this function can provide.
     ///
-    /// FIXME(#2267, pcwalton): It would be more efficient to not have to clone boxes all the time;
-    /// i.e. if `old_boxes` contained less info than the entire range of boxes. See
+    /// FIXME(#2267, pcwalton): It would be more efficient to not have to clone fragments all the time;
+    /// i.e. if `old_fragments` contained less info than the entire range of fragments. See
     /// `layout::construct::strip_ignorable_whitespace_from_start` for an example of some code that
-    /// needlessly has to clone boxes.
+    /// needlessly has to clone fragments.
     pub fn fixup(&mut self, old_fragments: &[Fragment], new_fragments: &[Fragment]) {
         // TODO(pcwalton): Post Rust upgrade, use `with_capacity` here.
         let old_list = mem::replace(&mut self.list, Vec::new());
diff --git a/src/components/main/layout/model.rs b/src/components/main/layout/model.rs
index 499c99339e5..a9f1bf2edbd 100644
--- a/src/components/main/layout/model.rs
+++ b/src/components/main/layout/model.rs
@@ -88,7 +88,7 @@ pub struct MarginCollapseInfo {
 }
 
 impl MarginCollapseInfo {
-    /// TODO(#2012, pcwalton): Remove this method once `box_` is not an `Option`.
+    /// TODO(#2012, pcwalton): Remove this method once `fragment` is not an `Option`.
     pub fn new() -> MarginCollapseInfo {
         MarginCollapseInfo {
             state: AccumulatingCollapsibleTopMargin,
@@ -120,15 +120,15 @@ impl MarginCollapseInfo {
                                 MarginsCollapseThroughFinalMarginState
                             },
                             _ => {
-                                // If the box has non-zero min-height, margins may not collapse
-                                // through it.
+                                // If the fragment has non-zero min-height, margins may not
+                                // collapse through it.
                                 BottomMarginCollapsesFinalMarginState
                             }
                         }
                     },
                     _ => {
-                        // If the box has an explicitly specified height, margins may not collapse
-                        // through it.
+                        // If the fragment has an explicitly specified height, margins may not
+                        // collapse through it.
                         BottomMarginCollapsesFinalMarginState
                     }
                 }
diff --git a/src/components/main/layout/table.rs b/src/components/main/layout/table.rs
index 5d90b64d701..522b1258dd2 100644
--- a/src/components/main/layout/table.rs
+++ b/src/components/main/layout/table.rs
@@ -19,9 +19,9 @@ use servo_util::geometry;
 use std::fmt;
 use style::computed_values::table_layout;
 
-/// A table flow corresponded to the table's internal table box under a table wrapper flow.
-/// The properties `position`, `float`, and `margin-*` are used on the table wrapper box,
-/// not table box per CSS 2.1 § 10.5.
+/// A table flow corresponded to the table's internal table fragment under a table wrapper flow.
+/// The properties `position`, `float`, and `margin-*` are used on the table wrapper fragment,
+/// not table fragment per CSS 2.1 § 10.5.
 pub struct TableFlow {
     pub block_flow: BlockFlow,
 
@@ -39,11 +39,11 @@ pub struct TableFlow {
 }
 
 impl TableFlow {
-    pub fn from_node_and_box(node: &ThreadSafeLayoutNode,
-                             box_: Fragment)
-                             -> TableFlow {
-        let mut block_flow = BlockFlow::from_node_and_box(node, box_);
-        let table_layout = if block_flow.box_().style().get_table().table_layout ==
+    pub fn from_node_and_fragment(node: &ThreadSafeLayoutNode,
+                                  fragment: Fragment)
+                                  -> TableFlow {
+        let mut block_flow = BlockFlow::from_node_and_fragment(node, fragment);
+        let table_layout = if block_flow.fragment().style().get_table().table_layout ==
                               table_layout::fixed {
             FixedLayout
         } else {
@@ -62,7 +62,7 @@ impl TableFlow {
                      node: &ThreadSafeLayoutNode)
                      -> TableFlow {
         let mut block_flow = BlockFlow::from_node(constructor, node);
-        let table_layout = if block_flow.box_().style().get_table().table_layout ==
+        let table_layout = if block_flow.fragment().style().get_table().table_layout ==
                               table_layout::fixed {
             FixedLayout
         } else {
@@ -82,7 +82,7 @@ impl TableFlow {
                            float_kind: FloatKind)
                            -> TableFlow {
         let mut block_flow = BlockFlow::float_from_node(constructor, node, float_kind);
-        let table_layout = if block_flow.box_().style().get_table().table_layout ==
+        let table_layout = if block_flow.fragment().style().get_table().table_layout ==
                               table_layout::fixed {
             FixedLayout
         } else {
@@ -231,8 +231,8 @@ impl Flow for TableFlow {
             geometry::max(min_width, pref_width);
     }
 
-    /// Recursively (top-down) determines the actual width of child contexts and boxes. When called
-    /// on this context, the context has had its width set by the parent context.
+    /// Recursively (top-down) determines the actual width of child contexts and fragments. When
+    /// called on this context, the context has had its width set by the parent context.
     fn assign_widths(&mut self, ctx: &mut LayoutContext) {
         debug!("assign_widths({}): assigning width for flow", "table");
 
@@ -252,9 +252,9 @@ impl Flow for TableFlow {
         let width_computer = InternalTable;
         width_computer.compute_used_width(&mut self.block_flow, ctx, containing_block_width);
 
-        let left_content_edge = self.block_flow.box_.border_padding.left;
-        let padding_and_borders = self.block_flow.box_.border_padding.horizontal();
-        let content_width = self.block_flow.box_.border_box.size.width - padding_and_borders;
+        let left_content_edge = self.block_flow.fragment.border_padding.left;
+        let padding_and_borders = self.block_flow.fragment.border_padding.horizontal();
+        let content_width = self.block_flow.fragment.border_box.size.width - padding_and_borders;
 
         match self.table_layout {
             FixedLayout => {
diff --git a/src/components/main/layout/table_cell.rs b/src/components/main/layout/table_cell.rs
index d48f2a19c42..56289020174 100644
--- a/src/components/main/layout/table_cell.rs
+++ b/src/components/main/layout/table_cell.rs
@@ -22,18 +22,18 @@ pub struct TableCellFlow {
 }
 
 impl TableCellFlow {
-    pub fn from_node_and_box(node: &ThreadSafeLayoutNode, box_: Fragment) -> TableCellFlow {
+    pub fn from_node_and_fragment(node: &ThreadSafeLayoutNode, fragment: Fragment) -> TableCellFlow {
         TableCellFlow {
-            block_flow: BlockFlow::from_node_and_box(node, box_)
+            block_flow: BlockFlow::from_node_and_fragment(node, fragment)
         }
     }
 
-    pub fn box_<'a>(&'a mut self) -> &'a Fragment {
-        &self.block_flow.box_
+    pub fn fragment<'a>(&'a mut self) -> &'a Fragment {
+        &self.block_flow.fragment
     }
 
-    pub fn mut_box<'a>(&'a mut self) -> &'a mut Fragment {
-        &mut self.block_flow.box_
+    pub fn mut_fragment<'a>(&'a mut self) -> &'a mut Fragment {
+        &mut self.block_flow.fragment
     }
 
     /// Assign height for table-cell flow.
@@ -69,7 +69,7 @@ impl Flow for TableCellFlow {
     /// Minimum/preferred widths set by this function are used in automatic table layout calculation.
     fn bubble_widths(&mut self, ctx: &mut LayoutContext) {
         self.block_flow.bubble_widths(ctx);
-        let specified_width = MaybeAuto::from_style(self.block_flow.box_.style().get_box().width,
+        let specified_width = MaybeAuto::from_style(self.block_flow.fragment.style().get_box().width,
                                                     Au::new(0)).specified_or_zero();
         if self.block_flow.base.intrinsic_widths.minimum_width < specified_width {
             self.block_flow.base.intrinsic_widths.minimum_width = specified_width;
@@ -81,8 +81,8 @@ impl Flow for TableCellFlow {
         }
     }
 
-    /// Recursively (top-down) determines the actual width of child contexts and boxes. When called
-    /// on this context, the context has had its width set by the parent table row.
+    /// Recursively (top-down) determines the actual width of child contexts and fragments. When
+    /// called on this context, the context has had its width set by the parent table row.
     fn assign_widths(&mut self, ctx: &mut LayoutContext) {
         debug!("assign_widths({}): assigning width for flow", "table_cell");
 
@@ -92,10 +92,10 @@ impl Flow for TableCellFlow {
         let width_computer = InternalTable;
         width_computer.compute_used_width(&mut self.block_flow, ctx, containing_block_width);
 
-        let left_content_edge = self.block_flow.box_.border_box.origin.x +
-            self.block_flow.box_.border_padding.left;
-        let padding_and_borders = self.block_flow.box_.border_padding.horizontal();
-        let content_width = self.block_flow.box_.border_box.size.width - padding_and_borders;
+        let left_content_edge = self.block_flow.fragment.border_box.origin.x +
+            self.block_flow.fragment.border_padding.left;
+        let padding_and_borders = self.block_flow.fragment.border_padding.horizontal();
+        let content_width = self.block_flow.fragment.border_box.size.width - padding_and_borders;
 
         self.block_flow.propagate_assigned_width_to_children(left_content_edge,
                                                              content_width,
diff --git a/src/components/main/layout/table_colgroup.rs b/src/components/main/layout/table_colgroup.rs
index 77188ea1926..05c56f55c7c 100644
--- a/src/components/main/layout/table_colgroup.rs
+++ b/src/components/main/layout/table_colgroup.rs
@@ -18,10 +18,10 @@ pub struct TableColGroupFlow {
     /// Data common to all flows.
     pub base: BaseFlow,
 
-    /// The associated box.
-    pub box_: Option<Fragment>,
+    /// The associated fragment.
+    pub fragment: Option<Fragment>,
 
-    /// The table column boxes
+    /// The table column fragments
     pub cols: Vec<Fragment>,
 
     /// The specified widths of table columns
@@ -29,13 +29,13 @@ pub struct TableColGroupFlow {
 }
 
 impl TableColGroupFlow {
-    pub fn from_node_and_boxes(node: &ThreadSafeLayoutNode,
-                               box_: Fragment,
-                               boxes: Vec<Fragment>) -> TableColGroupFlow {
+    pub fn from_node_and_fragments(node: &ThreadSafeLayoutNode,
+                                   fragment: Fragment,
+                                   fragments: Vec<Fragment>) -> TableColGroupFlow {
         TableColGroupFlow {
             base: BaseFlow::new((*node).clone()),
-            box_: Some(box_),
-            cols: boxes,
+            fragment: Some(fragment),
+            cols: fragments,
             widths: vec!(),
         }
     }
@@ -51,14 +51,14 @@ impl Flow for TableColGroupFlow {
     }
 
     fn bubble_widths(&mut self, _: &mut LayoutContext) {
-        for box_ in self.cols.iter() {
+        for fragment in self.cols.iter() {
             // get the specified value from width property
-            let width = MaybeAuto::from_style(box_.style().get_box().width,
+            let width = MaybeAuto::from_style(fragment.style().get_box().width,
                                               Au::new(0)).specified_or_zero();
 
-            let span: int = match box_.specific {
-                TableColumnFragment(col_box) => col_box.span.unwrap_or(1),
-                _ => fail!("Other box come out in TableColGroupFlow. {:?}", box_.specific)
+            let span: int = match fragment.specific {
+                TableColumnFragment(col_fragment) => col_fragment.span.unwrap_or(1),
+                _ => fail!("Other fragment come out in TableColGroupFlow. {:?}", fragment.specific)
             };
             for _ in range(0, span) {
                 self.widths.push(width);
@@ -78,7 +78,7 @@ impl Flow for TableColGroupFlow {
 
 impl fmt::Show for TableColGroupFlow {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self.box_ {
+        match self.fragment {
             Some(ref rb) => write!(f.buf, "TableColGroupFlow: {}", rb),
             None => write!(f.buf, "TableColGroupFlow"),
         }
diff --git a/src/components/main/layout/table_row.rs b/src/components/main/layout/table_row.rs
index 95efd34f53f..50867463175 100644
--- a/src/components/main/layout/table_row.rs
+++ b/src/components/main/layout/table_row.rs
@@ -34,11 +34,11 @@ pub struct TableRowFlow {
 }
 
 impl TableRowFlow {
-    pub fn from_node_and_box(node: &ThreadSafeLayoutNode,
-                             box_: Fragment)
-                             -> TableRowFlow {
+    pub fn from_node_and_fragment(node: &ThreadSafeLayoutNode,
+                                  fragment: Fragment)
+                                  -> TableRowFlow {
         TableRowFlow {
-            block_flow: BlockFlow::from_node_and_box(node, box_),
+            block_flow: BlockFlow::from_node_and_fragment(node, fragment),
             col_widths: vec!(),
             col_min_widths: vec!(),
             col_pref_widths: vec!(),
@@ -56,8 +56,8 @@ impl TableRowFlow {
         }
     }
 
-    pub fn box_<'a>(&'a mut self) -> &'a Fragment {
-        &self.block_flow.box_
+    pub fn fragment<'a>(&'a mut self) -> &'a Fragment {
+        &self.block_flow.fragment
     }
 
     fn initialize_offsets(&mut self) -> (Au, Au, Au) {
@@ -84,13 +84,13 @@ impl TableRowFlow {
             kid.assign_height_for_inorder_child_if_necessary(layout_context);
 
             {
-                let child_box = kid.as_table_cell().box_();
+                let child_fragment = kid.as_table_cell().fragment();
                 // TODO: Percentage height
-                let child_specified_height = MaybeAuto::from_style(child_box.style().get_box().height,
+                let child_specified_height = MaybeAuto::from_style(child_fragment.style().get_box().height,
                                                                    Au::new(0)).specified_or_zero();
                 max_y =
                     geometry::max(max_y,
-                                  child_specified_height + child_box.border_padding.vertical());
+                                  child_specified_height + child_fragment.border_padding.vertical());
             }
             let child_node = flow::mut_base(kid);
             child_node.position.origin.y = cur_y;
@@ -99,27 +99,27 @@ impl TableRowFlow {
 
         let mut height = max_y;
         // TODO: Percentage height
-        height = match MaybeAuto::from_style(self.block_flow.box_.style().get_box().height, Au(0)) {
+        height = match MaybeAuto::from_style(self.block_flow.fragment.style().get_box().height, Au(0)) {
             Auto => height,
             Specified(value) => geometry::max(value, height)
         };
         // cur_y = cur_y + height;
 
-        // Assign the height of own box
+        // Assign the height of own fragment
         //
         // FIXME(pcwalton): Take `cur_y` into account.
-        let mut position = self.block_flow.box_.border_box;
+        let mut position = self.block_flow.fragment.border_box;
         position.size.height = height;
-        self.block_flow.box_.border_box = position;
+        self.block_flow.fragment.border_box = position;
         self.block_flow.base.position.size.height = height;
 
-        // Assign the height of kid boxes, which is the same value as own height.
+        // Assign the height of kid fragments, which is the same value as own height.
         for kid in self.block_flow.base.child_iter() {
             {
-                let kid_box_ = kid.as_table_cell().mut_box();
-                let mut position = kid_box_.border_box;
+                let kid_fragment = kid.as_table_cell().mut_fragment();
+                let mut position = kid_fragment.border_box;
                 position.size.height = height;
-                kid_box_.border_box = position;
+                kid_fragment.border_box = position;
             }
             let child_node = flow::mut_base(kid);
             child_node.position.size.height = height;
@@ -159,7 +159,7 @@ impl Flow for TableRowFlow {
 
     /// Recursively (bottom-up) determines the context's preferred and minimum widths. When called
     /// on this context, all child contexts have had their min/pref widths set. This function must
-    /// decide min/pref widths based on child context widths and dimensions of any boxes it is
+    /// decide min/pref widths based on child context widths and dimensions of any fragments it is
     /// responsible for flowing.
     /// Min/pref widths set by this function are used in automatic table layout calculation.
     /// The specified column widths of children cells are used in fixed table layout calculation.
@@ -172,8 +172,8 @@ impl Flow for TableRowFlow {
 
             // collect the specified column widths of cells. These are used in fixed table layout calculation.
             {
-                let child_box = kid.as_table_cell().box_();
-                let child_specified_width = MaybeAuto::from_style(child_box.style().get_box().width,
+                let child_fragment = kid.as_table_cell().fragment();
+                let child_specified_width = MaybeAuto::from_style(child_fragment.style().get_box().width,
                                                                   Au::new(0)).specified_or_zero();
                 self.col_widths.push(child_specified_width);
             }
@@ -190,7 +190,7 @@ impl Flow for TableRowFlow {
                                                                               pref_width);
     }
 
-    /// Recursively (top-down) determines the actual width of child contexts and boxes. When called
+    /// Recursively (top-down) determines the actual width of child contexts and fragments. When called
     /// on this context, the context has had its width set by the parent context.
     fn assign_widths(&mut self, ctx: &mut LayoutContext) {
         debug!("assign_widths({}): assigning width for flow", "table_row");
@@ -218,6 +218,6 @@ impl Flow for TableRowFlow {
 
 impl fmt::Show for TableRowFlow {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f.buf, "TableRowFlow: {}", self.block_flow.box_)
+        write!(f.buf, "TableRowFlow: {}", self.block_flow.fragment)
     }
 }
diff --git a/src/components/main/layout/table_rowgroup.rs b/src/components/main/layout/table_rowgroup.rs
index b92f3bc0ccf..0d49597335d 100644
--- a/src/components/main/layout/table_rowgroup.rs
+++ b/src/components/main/layout/table_rowgroup.rs
@@ -33,11 +33,11 @@ pub struct TableRowGroupFlow {
 }
 
 impl TableRowGroupFlow {
-    pub fn from_node_and_box(node: &ThreadSafeLayoutNode,
-                             box_: Fragment)
-                             -> TableRowGroupFlow {
+    pub fn from_node_and_fragment(node: &ThreadSafeLayoutNode,
+                                  fragment: Fragment)
+                                  -> TableRowGroupFlow {
         TableRowGroupFlow {
-            block_flow: BlockFlow::from_node_and_box(node, box_),
+            block_flow: BlockFlow::from_node_and_fragment(node, fragment),
             col_widths: vec!(),
             col_min_widths: vec!(),
             col_pref_widths: vec!(),
@@ -55,8 +55,8 @@ impl TableRowGroupFlow {
         }
     }
 
-    pub fn box_<'a>(&'a mut self) -> &'a Fragment {
-        &self.block_flow.box_
+    pub fn fragment<'a>(&'a mut self) -> &'a Fragment {
+        &self.block_flow.fragment
     }
 
     fn initialize_offsets(&mut self) -> (Au, Au, Au) {
@@ -87,9 +87,9 @@ impl TableRowGroupFlow {
 
         let height = cur_y - top_offset;
 
-        let mut position = self.block_flow.box_.border_box;
+        let mut position = self.block_flow.fragment.border_box;
         position.size.height = height;
-        self.block_flow.box_.border_box = position;
+        self.block_flow.fragment.border_box = position;
         self.block_flow.base.position.size.height = height;
     }
 
@@ -126,7 +126,7 @@ impl Flow for TableRowGroupFlow {
 
     /// Recursively (bottom-up) determines the context's preferred and minimum widths. When called
     /// on this context, all child contexts have had their min/pref widths set. This function must
-    /// decide min/pref widths based on child context widths and dimensions of any boxes it is
+    /// decide min/pref widths based on child context widths and dimensions of any fragments it is
     /// responsible for flowing.
     /// Min/pref widths set by this function are used in automatic table layout calculation.
     /// Also, this function finds the specified column widths from the first row.
@@ -171,8 +171,8 @@ impl Flow for TableRowGroupFlow {
                                                                               pref_width);
     }
 
-    /// Recursively (top-down) determines the actual width of child contexts and boxes. When called
-    /// on this context, the context has had its width set by the parent context.
+    /// Recursively (top-down) determines the actual width of child contexts and fragments. When
+    /// called on this context, the context has had its width set by the parent context.
     fn assign_widths(&mut self, ctx: &mut LayoutContext) {
         debug!("assign_widths({}): assigning width for flow", "table_rowgroup");
 
@@ -200,6 +200,6 @@ impl Flow for TableRowGroupFlow {
 
 impl fmt::Show for TableRowGroupFlow {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f.buf, "TableRowGroupFlow: {}", self.block_flow.box_)
+        write!(f.buf, "TableRowGroupFlow: {}", self.block_flow.fragment)
     }
 }
diff --git a/src/components/main/layout/table_wrapper.rs b/src/components/main/layout/table_wrapper.rs
index f4d721d4435..91777a44da9 100644
--- a/src/components/main/layout/table_wrapper.rs
+++ b/src/components/main/layout/table_wrapper.rs
@@ -36,11 +36,11 @@ pub struct TableWrapperFlow {
 }
 
 impl TableWrapperFlow {
-    pub fn from_node_and_box(node: &ThreadSafeLayoutNode,
-                             box_: Fragment)
-                             -> TableWrapperFlow {
-        let mut block_flow = BlockFlow::from_node_and_box(node, box_);
-        let table_layout = if block_flow.box_().style().get_table().table_layout ==
+    pub fn from_node_and_fragment(node: &ThreadSafeLayoutNode,
+                                  fragment: Fragment)
+                                  -> TableWrapperFlow {
+        let mut block_flow = BlockFlow::from_node_and_fragment(node, fragment);
+        let table_layout = if block_flow.fragment().style().get_table().table_layout ==
                               table_layout::fixed {
             FixedLayout
         } else {
@@ -57,7 +57,7 @@ impl TableWrapperFlow {
                      node: &ThreadSafeLayoutNode)
                      -> TableWrapperFlow {
         let mut block_flow = BlockFlow::from_node(constructor, node);
-        let table_layout = if block_flow.box_().style().get_table().table_layout ==
+        let table_layout = if block_flow.fragment().style().get_table().table_layout ==
                               table_layout::fixed {
             FixedLayout
         } else {
@@ -75,7 +75,7 @@ impl TableWrapperFlow {
                            float_kind: FloatKind)
                            -> TableWrapperFlow {
         let mut block_flow = BlockFlow::float_from_node(constructor, node, float_kind);
-        let table_layout = if block_flow.box_().style().get_table().table_layout ==
+        let table_layout = if block_flow.fragment().style().get_table().table_layout ==
                               table_layout::fixed {
             FixedLayout
         } else {
@@ -125,7 +125,7 @@ impl Flow for TableWrapperFlow {
     minimum widths.  When called on this context, all child contexts
     have had their min/pref widths set. This function must decide
     min/pref widths based on child context widths and dimensions of
-    any boxes it is responsible for flowing.  */
+    any fragments it is responsible for flowing.  */
 
     fn bubble_widths(&mut self, ctx: &mut LayoutContext) {
         // get column widths info from table flow
@@ -140,10 +140,10 @@ impl Flow for TableWrapperFlow {
         self.block_flow.bubble_widths(ctx);
     }
 
-    /// Recursively (top-down) determines the actual width of child contexts and boxes. When called
-    /// on this context, the context has had its width set by the parent context.
+    /// Recursively (top-down) determines the actual width of child contexts and fragments. When
+    /// called on this context, the context has had its width set by the parent context.
     ///
-    /// Dual boxes consume some width first, and the remainder is assigned to all child (block)
+    /// Dual fragments consume some width first, and the remainder is assigned to all child (block)
     /// contexts.
     fn assign_widths(&mut self, ctx: &mut LayoutContext) {
         debug!("assign_widths({}): assigning width for flow",
@@ -159,8 +159,8 @@ impl Flow for TableWrapperFlow {
         let width_computer = TableWrapper;
         width_computer.compute_used_width_table_wrapper(self, ctx, containing_block_width);
 
-        let left_content_edge = self.block_flow.box_.border_box.origin.x;
-        let content_width = self.block_flow.box_.border_box.size.width;
+        let left_content_edge = self.block_flow.fragment.border_box.origin.x;
+        let content_width = self.block_flow.fragment.border_box.size.width;
 
         match self.table_layout {
             FixedLayout | _ if self.is_float() =>
@@ -194,9 +194,9 @@ impl Flow for TableWrapperFlow {
 impl fmt::Show for TableWrapperFlow {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if self.is_float() {
-            write!(f.buf, "TableWrapperFlow(Float): {}", self.block_flow.box_)
+            write!(f.buf, "TableWrapperFlow(Float): {}", self.block_flow.fragment)
         } else {
-            write!(f.buf, "TableWrapperFlow: {}", self.block_flow.box_)
+            write!(f.buf, "TableWrapperFlow: {}", self.block_flow.fragment)
         }
     }
 }
@@ -232,10 +232,10 @@ impl TableWrapper {
                                                                              |sum, width| sum.add(width));
 
                 let mut computed_width = input.computed_width.specified_or_zero();
-                let style = table_wrapper.block_flow.box_.style();
+                let style = table_wrapper.block_flow.fragment.style();
 
                 // Get left and right paddings, borders for table.
-                // We get these values from the box's style since table_wrapper doesn't have it's own border or padding.
+                // We get these values from the fragment's style since table_wrapper doesn't have it's own border or padding.
                 // input.available_width is same as containing_block_width in table_wrapper.
                 let padding_left = specified(style.get_padding().padding_left,
                                              input.available_width);
diff --git a/src/components/main/layout/text.rs b/src/components/main/layout/text.rs
index 4dd3fae53f0..5b663bac5d2 100644
--- a/src/components/main/layout/text.rs
+++ b/src/components/main/layout/text.rs
@@ -25,12 +25,12 @@ struct NewLinePositions {
 }
 
 // A helper function.
-fn can_coalesce_text_nodes(boxes: &[Fragment], left_i: uint, right_i: uint) -> bool {
+fn can_coalesce_text_nodes(fragments: &[Fragment], left_i: uint, right_i: uint) -> bool {
     assert!(left_i != right_i);
-    boxes[left_i].can_merge_with_box(&boxes[right_i])
+    fragments[left_i].can_merge_with_fragment(&fragments[right_i])
 }
 
-/// A stack-allocated object for scanning an inline flow into `TextRun`-containing `TextFragment`es.
+/// A stack-allocated object for scanning an inline flow into `TextRun`-containing `TextFragment`s.
 pub struct TextRunScanner {
     pub clump: Range<CharIndex>,
 }
@@ -45,22 +45,22 @@ impl TextRunScanner {
     pub fn scan_for_runs(&mut self, font_context: &mut FontContext, flow: &mut Flow) {
         {
             let inline = flow.as_immutable_inline();
-            debug!("TextRunScanner: scanning {:u} boxes for text runs...", inline.boxes.len());
+            debug!("TextRunScanner: scanning {:u} fragments for text runs...", inline.fragments.len());
         }
 
         let InlineFragments {
-            boxes: old_boxes,
+            fragments: old_fragments,
             map: mut map
-        } = mem::replace(&mut flow.as_inline().boxes, InlineFragments::new());
+        } = mem::replace(&mut flow.as_inline().fragments, InlineFragments::new());
 
         let mut last_whitespace = true;
-        let mut new_boxes = Vec::new();
-        for box_i in range(0, old_boxes.len()) {
-            debug!("TextRunScanner: considering box: {:u}", box_i);
-            if box_i > 0 && !can_coalesce_text_nodes(old_boxes.as_slice(), box_i - 1, box_i) {
+        let mut new_fragments = Vec::new();
+        for fragment_i in range(0, old_fragments.len()) {
+            debug!("TextRunScanner: considering fragment: {:u}", fragment_i);
+            if fragment_i > 0 && !can_coalesce_text_nodes(old_fragments.as_slice(), fragment_i - 1, fragment_i) {
                 last_whitespace = self.flush_clump_to_list(font_context,
-                                                           old_boxes.as_slice(),
-                                                           &mut new_boxes,
+                                                           old_fragments.as_slice(),
+                                                           &mut new_fragments,
                                                            last_whitespace);
             }
 
@@ -70,42 +70,42 @@ impl TextRunScanner {
         // Handle remaining clumps.
         if self.clump.length() > CharIndex(0) {
             drop(self.flush_clump_to_list(font_context,
-                                          old_boxes.as_slice(),
-                                          &mut new_boxes,
+                                          old_fragments.as_slice(),
+                                          &mut new_fragments,
                                           last_whitespace))
         }
 
-        debug!("TextRunScanner: swapping out boxes.");
+        debug!("TextRunScanner: swapping out fragments.");
 
-        // Swap out the old and new box list of the flow.
-        map.fixup(old_boxes.as_slice(), new_boxes.as_slice());
-        flow.as_inline().boxes = InlineFragments {
-            boxes: new_boxes,
+        // Swap out the old and new fragment list of the flow.
+        map.fixup(old_fragments.as_slice(), new_fragments.as_slice());
+        flow.as_inline().fragments = InlineFragments {
+            fragments: new_fragments,
             map: map,
         }
     }
 
-    /// A "clump" is a range of inline flow leaves that can be merged together into a single box.
-    /// Adjacent text with the same style can be merged, and nothing else can.
+    /// A "clump" is a range of inline flow leaves that can be merged together into a single
+    /// fragment. Adjacent text with the same style can be merged, and nothing else can.
     ///
-    /// The flow keeps track of the boxes contained by all non-leaf DOM nodes. This is necessary
-    /// for correct painting order. Since we compress several leaf boxes here, the mapping must be
-    /// adjusted.
+    /// The flow keeps track of the fragments contained by all non-leaf DOM nodes. This is necessary
+    /// for correct painting order. Since we compress several leaf fragments here, the mapping must
+    /// be adjusted.
     ///
-    /// FIXME(#2267, pcwalton): Stop cloning boxes. Instead we will need to replace each `in_box`
-    /// with some smaller stub.
+    /// FIXME(#2267, pcwalton): Stop cloning fragments. Instead we will need to replace each
+    /// `in_fragment` with some smaller stub.
     pub fn flush_clump_to_list(&mut self,
                                font_context: &mut FontContext,
-                               in_boxes: &[Fragment],
-                               out_boxes: &mut Vec<Fragment>,
+                               in_fragments: &[Fragment],
+                               out_fragments: &mut Vec<Fragment>,
                                last_whitespace: bool)
                                -> bool {
         assert!(self.clump.length() > CharIndex(0));
 
-        debug!("TextRunScanner: flushing boxes in range={}", self.clump);
+        debug!("TextRunScanner: flushing fragments in range={}", self.clump);
         let is_singleton = self.clump.length() == CharIndex(1);
 
-        let is_text_clump = match in_boxes[self.clump.begin().to_uint()].specific {
+        let is_text_clump = match in_fragments[self.clump.begin().to_uint()].specific {
             UnscannedTextFragment(_) => true,
             _ => false,
         };
@@ -116,23 +116,23 @@ impl TextRunScanner {
                 fail!("WAT: can't coalesce non-text nodes in flush_clump_to_list()!")
             }
             (true, false) => {
-                // FIXME(pcwalton): Stop cloning boxes, as above.
-                debug!("TextRunScanner: pushing single non-text box in range: {}", self.clump);
-                let new_box = in_boxes[self.clump.begin().to_uint()].clone();
-                out_boxes.push(new_box)
+                // FIXME(pcwalton): Stop cloning fragments, as above.
+                debug!("TextRunScanner: pushing single non-text fragment in range: {}", self.clump);
+                let new_fragment = in_fragments[self.clump.begin().to_uint()].clone();
+                out_fragments.push(new_fragment)
             },
             (true, true)  => {
-                let old_box = &in_boxes[self.clump.begin().to_uint()];
-                let text = match old_box.specific {
-                    UnscannedTextFragment(ref text_box_info) => &text_box_info.text,
-                    _ => fail!("Expected an unscanned text box!"),
+                let old_fragment = &in_fragments[self.clump.begin().to_uint()];
+                let text = match old_fragment.specific {
+                    UnscannedTextFragment(ref text_fragment_info) => &text_fragment_info.text,
+                    _ => fail!("Expected an unscanned text fragment!"),
                 };
 
-                let font_style = old_box.font_style();
-                let decoration = old_box.text_decoration();
+                let font_style = old_fragment.font_style();
+                let decoration = old_fragment.text_decoration();
 
                 // TODO(#115): Use the actual CSS `white-space` property of the relevant style.
-                let compression = match old_box.white_space() {
+                let compression = match old_fragment.white_space() {
                     white_space::normal => CompressWhitespaceNewline,
                     white_space::pre => CompressNone,
                 };
@@ -154,29 +154,29 @@ impl TextRunScanner {
                     let run = box fontgroup.borrow().create_textrun(
                         transformed_text.clone(), decoration);
 
-                    debug!("TextRunScanner: pushing single text box in range: {} ({})",
+                    debug!("TextRunScanner: pushing single text fragment in range: {} ({})",
                            self.clump,
                            *text);
                     let range = Range::new(CharIndex(0), run.char_len());
                     let new_metrics = run.metrics_for_range(&range);
-                    let new_text_box_info = ScannedTextFragmentInfo::new(Arc::new(run), range);
-                    let mut new_box = old_box.transform(new_metrics.bounding_box.size,
-                                                        ScannedTextFragment(new_text_box_info));
-                    new_box.new_line_pos = new_line_pos;
-                    out_boxes.push(new_box)
+                    let new_text_fragment_info = ScannedTextFragmentInfo::new(Arc::new(run), range);
+                    let mut new_fragment = old_fragment.transform(new_metrics.bounding_box.size,
+                                                                  ScannedTextFragment(new_text_fragment_info));
+                    new_fragment.new_line_pos = new_line_pos;
+                    out_fragments.push(new_fragment)
                 }
             },
             (false, true) => {
                 // TODO(#177): Text run creation must account for the renderability of text by
                 // font group fonts. This is probably achieved by creating the font group above
                 // and then letting `FontGroup` decide which `Font` to stick into the text run.
-                let in_box = &in_boxes[self.clump.begin().to_uint()];
-                let font_style = in_box.font_style();
+                let in_fragment = &in_fragments[self.clump.begin().to_uint()];
+                let font_style = in_fragment.font_style();
                 let fontgroup = font_context.get_resolved_font_for_style(&font_style);
-                let decoration = in_box.text_decoration();
+                let decoration = in_fragment.text_decoration();
 
                 // TODO(#115): Use the actual CSS `white-space` property of the relevant style.
-                let compression = match in_box.white_space() {
+                let compression = match in_fragment.white_space() {
                     white_space::normal => CompressWhitespaceNewline,
                     white_space::pre => CompressNone,
                 };
@@ -187,17 +187,17 @@ impl TextRunScanner {
                 let mut last_whitespace_in_clump = new_whitespace;
                 let transformed_strs: Vec<~str> = Vec::from_fn(self.clump.length().to_uint(), |i| {
                     // TODO(#113): We should be passing the compression context between calls to
-                    // `transform_text`, so that boxes starting and/or ending with whitespace can
+                    // `transform_text`, so that fragments starting and/or ending with whitespace can
                     // be compressed correctly with respect to the text run.
                     let idx = CharIndex(i as int) + self.clump.begin();
-                    let in_box = match in_boxes[idx.to_uint()].specific {
-                        UnscannedTextFragment(ref text_box_info) => &text_box_info.text,
-                        _ => fail!("Expected an unscanned text box!"),
+                    let in_fragment = match in_fragments[idx.to_uint()].specific {
+                        UnscannedTextFragment(ref text_fragment_info) => &text_fragment_info.text,
+                        _ => fail!("Expected an unscanned text fragment!"),
                     };
 
                     let mut new_line_pos = vec![];
 
-                    let (new_str, new_whitespace) = transform_text(*in_box,
+                    let (new_str, new_whitespace) = transform_text(*in_fragment,
                                                                    compression,
                                                                    last_whitespace_in_clump,
                                                                    &mut new_line_pos);
@@ -232,23 +232,23 @@ impl TextRunScanner {
                     None
                 };
 
-                // Make new boxes with the run and adjusted text indices.
-                debug!("TextRunScanner: pushing box(es) in range: {}", self.clump);
+                // Make new fragments with the run and adjusted text indices.
+                debug!("TextRunScanner: pushing fragment(s) in range: {}", self.clump);
                 for i in clump.each_index() {
                     let logical_offset = i - self.clump.begin();
                     let range = new_ranges.get(logical_offset.to_uint());
                     if range.length() == CharIndex(0) {
-                        debug!("Elided an `UnscannedTextbox` because it was zero-length after \
-                                compression; {}", in_boxes[i.to_uint()]);
+                        debug!("Elided an `UnscannedTextFragment` because it was zero-length after \
+                                compression; {}", in_fragments[i.to_uint()]);
                         continue
                     }
 
-                    let new_text_box_info = ScannedTextFragmentInfo::new(run.get_ref().clone(), *range);
-                    let new_metrics = new_text_box_info.run.metrics_for_range(range);
-                    let mut new_box = in_boxes[i.to_uint()].transform(new_metrics.bounding_box.size,
-                                                            ScannedTextFragment(new_text_box_info));
-                    new_box.new_line_pos = new_line_positions.get(logical_offset.to_uint()).new_line_pos.clone();
-                    out_boxes.push(new_box)
+                    let new_text_fragment_info = ScannedTextFragmentInfo::new(run.get_ref().clone(), *range);
+                    let new_metrics = new_text_fragment_info.run.metrics_for_range(range);
+                    let mut new_fragment = in_fragments[i.to_uint()].transform(new_metrics.bounding_box.size,
+                                                                               ScannedTextFragment(new_text_fragment_info));
+                    new_fragment.new_line_pos = new_line_positions.get(logical_offset.to_uint()).new_line_pos.clone();
+                    out_fragments.push(new_fragment)
                 }
             }
         } // End of match.