Fix borrow-check and repo errors.

src/components/main/css/select_handler.rs

@@ -48,6 +48,15 @@ impl SelectHandler<AbstractNode<LayoutView>> for NodeSelectHandler {
         node.parent_node()
     }
 
+    //Stub implementations. TODO: fill out by merging PR 499
+    fn node_has_class(&self, node: &AbstractNode<LayoutView>, class: &str) -> bool{
+        false
+    }
+
+    fn with_node_classes<R>(&self, node: &AbstractNode<LayoutView>, f: &fn(Option<&str>) -> R) -> R{
+        f(Some(""))
+    }
+
     // TODO: Use a Bloom filter.
     fn named_ancestor_node(&self, node: &AbstractNode<LayoutView>, name: &str)
                            -> Option<AbstractNode<LayoutView>> {

src/components/main/layout/block.rs

@@ -106,8 +106,9 @@ impl BlockFlowData {
            these widths will not include child elements, just padding etc. */
         self.box.map(|&box| {
             //Can compute border width here since it doesn't depend on anything
+            let style = &box.style();
             do box.with_model |model| {
-                model.compute_borders(box.style())
+                model.compute_borders(*style);
             }
             min_width = min_width.add(&box.get_min_width(ctx));
             pref_width = pref_width.add(&box.get_pref_width(ctx));
@@ -184,20 +185,21 @@ impl BlockFlowData {
         let mut x_offset = Au(0);
 
         self.box.map(|&box| {
+            let style = &box.style();
             do box.with_model |model| {
                 //Can compute padding here since we know containing block width
-                model.compute_padding(box.style(), remaining_width);
+                model.compute_padding(*style, remaining_width);
 
                 //Margins are 0 right now so model.noncontent_width() is just borders + padding.
                 let available_width = remaining_width - model.noncontent_width();
 
                 //Top and bottom margins for blocks are 0 if auto
-                let margin_top = MaybeAuto::from_margin(box.style().margin_top()).spec_or_default(Au(0));
-                let margin_bottom = MaybeAuto::from_margin(box.style().margin_bottom()).spec_or_default(Au(0));
+                let margin_top = MaybeAuto::from_margin(style.margin_top()).spec_or_default(Au(0));
+                let margin_bottom = MaybeAuto::from_margin(style.margin_bottom()).spec_or_default(Au(0));
 
-                let (width, margin_left, margin_right) = (MaybeAuto::from_width(box.style().width()),
-                    MaybeAuto::from_margin(box.style().margin_left()),
-                    MaybeAuto::from_margin(box.style().margin_right()));
+                let (width, margin_left, margin_right) = (MaybeAuto::from_width(style.width()),
+                    MaybeAuto::from_margin(style.margin_left()),
+                    MaybeAuto::from_margin(style.margin_right()));
 
                 let (width, margin_left, margin_right) = 
                     self.compute_horiz(width, margin_left, margin_right, available_width);

src/components/main/layout/box.rs

@@ -449,7 +449,7 @@ pub impl RenderBox {
     }
 
     fn with_model<R>(&self, callback: &fn(&mut BoxModel) -> R) ->  R {
-        do self.with_imm_base |base| {
+        do self.with_mut_base |base| {
             callback(&mut base.model)
         }
     }

src/components/main/layout/model.rs

@@ -126,7 +126,7 @@ impl BoxModel {
         }
     }
 
-    priv fn compute_padding(&self, padding: CSSPadding, cb_width: Au) -> Au{
+    priv fn compute_padding_length(&self, padding: CSSPadding, cb_width: Au) -> Au{
         match padding {
             CSSPaddingLength(Px(v)) |
             CSSPaddingLength(Pt(v)) |