diff --git a/components/layout/query.rs b/components/layout/query.rs
index 6ff92e1b5bc..c92af15582f 100644
--- a/components/layout/query.rs
+++ b/components/layout/query.rs
@@ -9,8 +9,7 @@ use construct::ConstructionResult;
 use euclid::point::Point2D;
 use euclid::rect::Rect;
 use euclid::size::Size2D;
-use flow;
-use flow_ref::{self, FlowRef};
+use flow::{self, Flow};
 use fragment::{Fragment, FragmentBorderBoxIterator, SpecificFragmentInfo};
 use gfx::display_list::{DisplayItemMetadata, DisplayList, OpaqueNode, ScrollOffsetMap};
 use gfx_traits::LayerId;
@@ -375,23 +374,23 @@ impl FragmentBorderBoxIterator for MarginRetrievingFragmentBorderBoxIterator {
 }
 
 pub fn process_content_box_request<N: LayoutNode>(
-        requested_node: N, layout_root: &mut FlowRef) -> Rect<Au> {
+        requested_node: N, layout_root: &mut Flow) -> Rect<Au> {
     // FIXME(pcwalton): This has not been updated to handle the stacking context relative
     // stuff. So the position is wrong in most cases.
     let mut iterator = UnioningFragmentBorderBoxIterator::new(requested_node.opaque());
-    sequential::iterate_through_flow_tree_fragment_border_boxes(flow_ref::deref_mut(layout_root), &mut iterator);
+    sequential::iterate_through_flow_tree_fragment_border_boxes(layout_root, &mut iterator);
     match iterator.rect {
         Some(rect) => rect,
         None       => Rect::zero()
     }
 }
 
-pub fn process_content_boxes_request<N: LayoutNode>(requested_node: N, layout_root: &mut FlowRef)
+pub fn process_content_boxes_request<N: LayoutNode>(requested_node: N, layout_root: &mut Flow)
         -> Vec<Rect<Au>> {
     // FIXME(pcwalton): This has not been updated to handle the stacking context relative
     // stuff. So the position is wrong in most cases.
     let mut iterator = CollectingFragmentBorderBoxIterator::new(requested_node.opaque());
-    sequential::iterate_through_flow_tree_fragment_border_boxes(flow_ref::deref_mut(layout_root), &mut iterator);
+    sequential::iterate_through_flow_tree_fragment_border_boxes(layout_root, &mut iterator);
     iterator.rects
 }
 
@@ -581,10 +580,10 @@ impl FragmentBorderBoxIterator for ParentOffsetBorderBoxIterator {
     }
 }
 
-pub fn process_node_geometry_request<N: LayoutNode>(requested_node: N, layout_root: &mut FlowRef)
+pub fn process_node_geometry_request<N: LayoutNode>(requested_node: N, layout_root: &mut Flow)
         -> Rect<i32> {
     let mut iterator = FragmentLocatingFragmentIterator::new(requested_node.opaque());
-    sequential::iterate_through_flow_tree_fragment_border_boxes(flow_ref::deref_mut(layout_root), &mut iterator);
+    sequential::iterate_through_flow_tree_fragment_border_boxes(layout_root, &mut iterator);
     iterator.client_rect
 }
 
@@ -593,10 +592,10 @@ pub fn process_node_layer_id_request<N: LayoutNode>(requested_node: N) -> LayerI
     layout_node.layer_id()
 }
 
-pub fn process_node_scroll_area_request< N: LayoutNode>(requested_node: N, layout_root: &mut FlowRef)
+pub fn process_node_scroll_area_request< N: LayoutNode>(requested_node: N, layout_root: &mut Flow)
         -> Rect<i32> {
     let mut iterator = UnioningFragmentScrollAreaIterator::new(requested_node.opaque());
-    sequential::iterate_through_flow_tree_fragment_border_boxes(flow_ref::deref_mut(layout_root), &mut iterator);
+    sequential::iterate_through_flow_tree_fragment_border_boxes(layout_root, &mut iterator);
     match iterator.overflow_direction {
         OverflowDirection::RightAndDown => {
             let right = max(iterator.union_rect.size.width, iterator.origin_rect.size.width);
@@ -643,7 +642,7 @@ pub fn process_resolved_style_request<'a, N, C>(requested_node: N,
                                                 style_context: &'a C,
                                                 pseudo: &Option<PseudoElement>,
                                                 property: &Atom,
-                                                layout_root: &mut FlowRef) -> Option<String>
+                                                layout_root: &mut Flow) -> Option<String>
     where N: LayoutNode,
           C: StyleContext<'a>
 {
@@ -695,7 +694,7 @@ pub fn process_resolved_style_request<'a, N, C>(requested_node: N,
 
     fn used_value_for_position_property<N: LayoutNode>(
             layout_node: N::ConcreteThreadSafeLayoutNode,
-            layout_root: &mut FlowRef,
+            layout_root: &mut Flow,
             requested_node: N,
             property: &Atom) -> Option<String> {
         let maybe_data = layout_node.borrow_layout_data();
@@ -721,7 +720,7 @@ pub fn process_resolved_style_request<'a, N, C>(requested_node: N,
             PositionRetrievingFragmentBorderBoxIterator::new(requested_node.opaque(),
                                                              property,
                                                              position);
-        sequential::iterate_through_flow_tree_fragment_border_boxes(flow_ref::deref_mut(layout_root),
+        sequential::iterate_through_flow_tree_fragment_border_boxes(layout_root,
                                                                     &mut iterator);
         iterator.result.map(|r| r.to_css_string())
     }
@@ -751,7 +750,7 @@ pub fn process_resolved_style_request<'a, N, C>(requested_node: N,
                                                                side,
                                                                margin_padding,
                                                                style.writing_mode);
-            sequential::iterate_through_flow_tree_fragment_border_boxes(flow_ref::deref_mut(layout_root),
+            sequential::iterate_through_flow_tree_fragment_border_boxes(layout_root,
                                                                         &mut iterator);
             iterator.result.map(|r| r.to_css_string())
         },
@@ -774,10 +773,10 @@ pub fn process_resolved_style_request<'a, N, C>(requested_node: N,
     }
 }
 
-pub fn process_offset_parent_query<N: LayoutNode>(requested_node: N, layout_root: &mut FlowRef)
+pub fn process_offset_parent_query<N: LayoutNode>(requested_node: N, layout_root: &mut Flow)
         -> OffsetParentResponse {
     let mut iterator = ParentOffsetBorderBoxIterator::new(requested_node.opaque());
-    sequential::iterate_through_flow_tree_fragment_border_boxes(flow_ref::deref_mut(layout_root), &mut iterator);
+    sequential::iterate_through_flow_tree_fragment_border_boxes(layout_root, &mut iterator);
     let parent_info_index = iterator.parent_nodes.iter().rposition(|info| info.is_some());
     match parent_info_index {
         Some(parent_info_index) => {
diff --git a/components/layout_thread/lib.rs b/components/layout_thread/lib.rs
index 86b962a7ca7..05a983b274d 100644
--- a/components/layout_thread/lib.rs
+++ b/components/layout_thread/lib.rs
@@ -1209,14 +1209,15 @@ impl LayoutThread {
                                                      &mut shared_layout_context);
 
         if let Some(mut root_flow) = self.root_flow.clone() {
+            let root_flow = flow_ref::deref_mut(&mut root_flow);
             match data.query_type {
                 ReflowQueryType::ContentBoxQuery(node) => {
                     let node = unsafe { ServoLayoutNode::new(&node) };
-                    rw_data.content_box_response = process_content_box_request(node, &mut root_flow);
+                    rw_data.content_box_response = process_content_box_request(node, root_flow);
                 },
                 ReflowQueryType::ContentBoxesQuery(node) => {
                     let node = unsafe { ServoLayoutNode::new(&node) };
-                    rw_data.content_boxes_response = process_content_boxes_request(node, &mut root_flow);
+                    rw_data.content_boxes_response = process_content_boxes_request(node, root_flow);
                 },
                 ReflowQueryType::HitTestQuery(translated_point, client_point, update_cursor) => {
                     let translated_point =
@@ -1237,11 +1238,11 @@ impl LayoutThread {
                 },
                 ReflowQueryType::NodeGeometryQuery(node) => {
                     let node = unsafe { ServoLayoutNode::new(&node) };
-                    rw_data.client_rect_response = process_node_geometry_request(node, &mut root_flow);
+                    rw_data.client_rect_response = process_node_geometry_request(node, root_flow);
                 },
                 ReflowQueryType::NodeScrollGeometryQuery(node) => {
                     let node = unsafe { ServoLayoutNode::new(&node) };
-                    rw_data.scroll_area_response = process_node_scroll_area_request(node, &mut root_flow);
+                    rw_data.scroll_area_response = process_node_scroll_area_request(node, root_flow);
                 },
                 ReflowQueryType::NodeOverflowQuery(node) => {
                     let node = unsafe { ServoLayoutNode::new(&node) };
@@ -1259,11 +1260,11 @@ impl LayoutThread {
                                                        &layout_context,
                                                        pseudo,
                                                        property,
-                                                       &mut root_flow);
+                                                       root_flow);
                 },
                 ReflowQueryType::OffsetParentQuery(node) => {
                     let node = unsafe { ServoLayoutNode::new(&node) };
-                    rw_data.offset_parent_response = process_offset_parent_query(node, &mut root_flow);
+                    rw_data.offset_parent_response = process_offset_parent_query(node, root_flow);
                 },
                 ReflowQueryType::MarginStyleQuery(node) => {
                     let node = unsafe { ServoLayoutNode::new(&node) };