Let RangeboundaryPoint::container_node_ be reference.

third_party/WebKit/Source/core/dom/Range.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Gunnstein Lye (gunnstein@netcom.no)
  * (C) 2000 Frederik Holljen (frederik.holljen@hig.no)
  * (C) 2001 Peter Kelly (pmk@post.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2011 Motorola Mobility. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 97 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(RangeUpdateScope);
 };
 
 int RangeUpdateScope::scope_count_ = 0;
 #if DCHECK_IS_ON()
 Range* RangeUpdateScope::current_range_;
 #endif
 
 inline Range::Range(Document& owner_document)
     : owner_document_(&owner_document),
-      start_(owner_document_),
-      end_(owner_document_) {
+      start_(*owner_document_),
+      end_(*owner_document_) {
   owner_document_->AttachRange(this);
 }
 
 Range* Range::Create(Document& owner_document) {
   return new Range(owner_document);
 }
 
 inline Range::Range(Document& owner_document,
                     Node* start_container,
                     unsigned start_offset,
                     Node* end_container,
                     unsigned end_offset)
     : owner_document_(&owner_document),
-      start_(owner_document_),
-      end_(owner_document_) {
+      start_(*owner_document_),
+      end_(*owner_document_) {
   owner_document_->AttachRange(this);
 
   // Simply setting the containers and offsets directly would not do any of the
   // checking that setStart and setEnd do, so we call those functions.
   setStart(start_container, start_offset);
   setEnd(end_container, end_offset);
 }
 
 Range* Range::Create(Document& owner_document,
                      Node* start_container,
@@ skipping 43 matching lines @@
   DCHECK_NE(owner_document_, document);
   DCHECK(owner_document_);
   owner_document_->DetachRange(this);
   owner_document_ = &document;
   start_.SetToStartOfNode(document);
   end_.SetToStartOfNode(document);
   owner_document_->AttachRange(this);
 }
 
 Node* Range::commonAncestorContainer() const {
-  return commonAncestorContainer(start_.Container(), end_.Container());
+  return commonAncestorContainer(&start_.Container(), &end_.Container());
 }
 
 Node* Range::commonAncestorContainer(const Node* container_a,
                                      const Node* container_b) {
   if (!container_a || !container_b)
     return nullptr;
   return container_a->CommonAncestor(*container_b, NodeTraversal::Parent);
 }
 
 static inline bool CheckForDifferentRootContainer(
     const RangeBoundaryPoint& start,
     const RangeBoundaryPoint& end) {
-  Node* end_root_container = end.Container();
+  Node* end_root_container = &end.Container();
   while (end_root_container->parentNode())
     end_root_container = end_root_container->parentNode();
-  Node* start_root_container = start.Container();
+  Node* start_root_container = &start.Container();
   while (start_root_container->parentNode())
     start_root_container = start_root_container->parentNode();
 
   return start_root_container != end_root_container ||
          (Range::compareBoundaryPoints(start, end, ASSERT_NO_EXCEPTION) > 0);
 }
 
 void Range::setStart(Node* ref_node,
                      unsigned offset,
                      ExceptionState& exception_state) {
   if (!ref_node) {
     // FIXME: Generated bindings code never calls with null, and neither should
     // other callers!
     exception_state.ThrowTypeError("The node provided is null.");
     return;
   }
 
   RangeUpdateScope scope(this);
   bool did_move_document = false;
   if (ref_node->GetDocument() != owner_document_) {
     SetDocument(ref_node->GetDocument());
     did_move_document = true;
   }
 
   Node* child_node = CheckNodeWOffset(ref_node, offset, exception_state);
   if (exception_state.HadException())
     return;
 
-  start_.Set(ref_node, offset, child_node);
+  start_.Set(*ref_node, offset, child_node);
 
   if (did_move_document || CheckForDifferentRootContainer(start_, end_))
     collapse(true);
 }
 
 void Range::setEnd(Node* ref_node,
                    unsigned offset,
                    ExceptionState& exception_state) {
   if (!ref_node) {
     // FIXME: Generated bindings code never calls with null, and neither should
     // other callers!
     exception_state.ThrowTypeError("The node provided is null.");
     return;
   }
 
   RangeUpdateScope scope(this);
   bool did_move_document = false;
   if (ref_node->GetDocument() != owner_document_) {
     SetDocument(ref_node->GetDocument());
     did_move_document = true;
   }
 
   Node* child_node = CheckNodeWOffset(ref_node, offset, exception_state);
   if (exception_state.HadException())
     return;
 
-  end_.Set(ref_node, offset, child_node);
+  end_.Set(*ref_node, offset, child_node);
 
   if (did_move_document || CheckForDifferentRootContainer(start_, end_))
     collapse(false);
 }
 
 void Range::setStart(const Position& start, ExceptionState& exception_state) {
   Position parent_anchored = start.ParentAnchoredEquivalent();
   setStart(parent_anchored.ComputeContainerNode(),
            parent_anchored.OffsetInContainerNode(), exception_state);
 }
@@ skipping 10 matching lines @@
     end_ = start_;
   else
     start_ = end_;
 }
 
 bool Range::HasSameRoot(const Node& node) const {
   if (node.GetDocument() != owner_document_)
     return false;
   // commonAncestorContainer() is O(depth). We should avoid to call it in common
   // cases.
-  if (node.IsInTreeScope() && start_.Container()->IsInTreeScope() &&
-      &node.GetTreeScope() == &start_.Container()->GetTreeScope())
+  if (node.IsInTreeScope() && start_.Container().IsInTreeScope() &&
+      &node.GetTreeScope() == &start_.Container().GetTreeScope())
     return true;
-  return node.CommonAncestor(*start_.Container(), NodeTraversal::Parent);
+  return node.CommonAncestor(start_.Container(), NodeTraversal::Parent);
 }
 
 bool Range::isPointInRange(Node* ref_node,
                            unsigned offset,
                            ExceptionState& exception_state) const {
   if (!ref_node) {
     // FIXME: Generated bindings code never calls with null, and neither should
     // other callers!
     exception_state.ThrowTypeError("The node provided is null.");
     return false;
   }
   if (!HasSameRoot(*ref_node))
     return false;
 
   CheckNodeWOffset(ref_node, offset, exception_state);
   if (exception_state.HadException())
     return false;
 
-  return compareBoundaryPoints(ref_node, offset, start_.Container(),
+  return compareBoundaryPoints(ref_node, offset, &start_.Container(),
                                start_.Offset(), exception_state) >= 0 &&
          !exception_state.HadException() &&
-         compareBoundaryPoints(ref_node, offset, end_.Container(),
+         compareBoundaryPoints(ref_node, offset, &end_.Container(),
                                end_.Offset(), exception_state) <= 0 &&
          !exception_state.HadException();
 }
 
 short Range::comparePoint(Node* ref_node,
                           unsigned offset,
                           ExceptionState& exception_state) const {
   // http://developer.mozilla.org/en/docs/DOM:range.comparePoint
   // This method returns -1, 0 or 1 depending on if the point described by the
   // refNode node and an offset within the node is before, same as, or after the
   // range respectively.
 
   if (!HasSameRoot(*ref_node)) {
     exception_state.ThrowDOMException(
         kWrongDocumentError,
         "The node provided and the Range are not in the same tree.");
     return 0;
   }
 
   CheckNodeWOffset(ref_node, offset, exception_state);
   if (exception_state.HadException())
     return 0;
 
   // compare to start, and point comes before
-  if (compareBoundaryPoints(ref_node, offset, start_.Container(),
+  if (compareBoundaryPoints(ref_node, offset, &start_.Container(),
                             start_.Offset(), exception_state) < 0)
     return -1;
 
   if (exception_state.HadException())
     return 0;
 
   // compare to end, and point comes after
-  if (compareBoundaryPoints(ref_node, offset, end_.Container(), end_.Offset(),
+  if (compareBoundaryPoints(ref_node, offset, &end_.Container(), end_.Offset(),
                             exception_state) > 0 &&
       !exception_state.HadException())
     return 1;
 
   // point is in the middle of this range, or on the boundary points
   return 0;
 }
 
 short Range::compareBoundaryPoints(unsigned how,
                                    const Range* source_range,
@@ skipping 58 matching lines @@
     exception_state.ThrowDOMException(
         kWrongDocumentError, "The two ranges are in separate documents.");
     return 0;
   }
   return result;
 }
 
 short Range::compareBoundaryPoints(const RangeBoundaryPoint& boundary_a,
                                    const RangeBoundaryPoint& boundary_b,
                                    ExceptionState& exception_state) {
-  return compareBoundaryPoints(boundary_a.Container(), boundary_a.Offset(),
-                               boundary_b.Container(), boundary_b.Offset(),
+  return compareBoundaryPoints(&boundary_a.Container(), boundary_a.Offset(),
+                               &boundary_b.Container(), boundary_b.Offset(),
                                exception_state);
 }
 
 bool Range::BoundaryPointsValid() const {
   DummyExceptionStateForTesting exception_state;
   return compareBoundaryPoints(start_, end_, exception_state) <= 0 &&
          !exception_state.HadException();
 }
 
 void Range::deleteContents(ExceptionState& exception_state) {
@@ skipping 103 matching lines @@
   if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS)
     fragment = DocumentFragment::Create(*owner_document_.Get());
 
   if (collapsed())
     return fragment;
 
   Node* common_root = commonAncestorContainer();
   DCHECK(common_root);
 
   if (start_.Container() == end_.Container()) {
-    ProcessContentsBetweenOffsets(action, fragment, start_.Container(),
+    ProcessContentsBetweenOffsets(action, fragment, &start_.Container(),
                                   start_.Offset(), end_.Offset(),
                                   exception_state);
     return fragment;
   }
 
   // Since mutation observers can modify the range during the process, the
   // boundary points need to be saved.
   const RangeBoundaryPoint original_start(start_);
   const RangeBoundaryPoint original_end(end_);
 
   // what is the highest node that partially selects the start / end of the
   // range?
   Node* partial_start =
-      HighestAncestorUnderCommonRoot(original_start.Container(), common_root);
+      HighestAncestorUnderCommonRoot(&original_start.Container(), common_root);
   Node* partial_end =
-      HighestAncestorUnderCommonRoot(original_end.Container(), common_root);
+      HighestAncestorUnderCommonRoot(&original_end.Container(), common_root);
 
   // Start and end containers are different.
   // There are three possibilities here:
   // 1. Start container == commonRoot (End container must be a descendant)
   // 2. End container == commonRoot (Start container must be a descendant)
   // 3. Neither is commonRoot, they are both descendants
   //
   // In case 3, we grab everything after the start (up until a direct child
   // of commonRoot) into leftContents, and everything before the end (up until
   // a direct child of commonRoot) into rightContents. Then we process all
   // commonRoot children between leftContents and rightContents
   //
   // In case 1 or 2, we skip either processing of leftContents or rightContents,
   // in which case the last lot of nodes either goes from the first or last
   // child of commonRoot.
   //
   // These are deleted, cloned, or extracted (i.e. both) depending on action.
 
   // Note that we are verifying that our common root hierarchy is still intact
   // after any DOM mutation event, at various stages below. See webkit bug
   // 60350.
 
   Node* left_contents = nullptr;
   if (original_start.Container() != common_root &&
-      common_root->contains(original_start.Container())) {
+      common_root->contains(&original_start.Container())) {
     left_contents = ProcessContentsBetweenOffsets(
-        action, nullptr, original_start.Container(), original_start.Offset(),
-        LengthOfContents(original_start.Container()), exception_state);
+        action, nullptr, &original_start.Container(), original_start.Offset(),
+        LengthOfContents(&original_start.Container()), exception_state);
     left_contents = ProcessAncestorsAndTheirSiblings(
-        action, original_start.Container(), kProcessContentsForward,
+        action, &original_start.Container(), kProcessContentsForward,
         left_contents, common_root, exception_state);
   }
 
   Node* right_contents = nullptr;
   if (end_.Container() != common_root &&
-      common_root->contains(original_end.Container())) {
+      common_root->contains(&original_end.Container())) {
     right_contents = ProcessContentsBetweenOffsets(
-        action, nullptr, original_end.Container(), 0, original_end.Offset(),
+        action, nullptr, &original_end.Container(), 0, original_end.Offset(),
         exception_state);
     right_contents = ProcessAncestorsAndTheirSiblings(
-        action, original_end.Container(), kProcessContentsBackward,
+        action, &original_end.Container(), kProcessContentsBackward,
         right_contents, common_root, exception_state);
   }
 
   // delete all children of commonRoot between the start and end container
   Node* process_start = ChildOfCommonRootBeforeOffset(
-      original_start.Container(), original_start.Offset(), common_root);
+      &original_start.Container(), original_start.Offset(), common_root);
   if (process_start &&
       original_start.Container() !=
           common_root)  // processStart contains nodes before m_start.
     process_start = process_start->nextSibling();
   Node* process_end = ChildOfCommonRootBeforeOffset(
-      original_end.Container(), original_end.Offset(), common_root);
+      &original_end.Container(), original_end.Offset(), common_root);
 
   // Collapse the range, making sure that the result is not within a node that
   // was partially selected.
   if (action == EXTRACT_CONTENTS || action == DELETE_CONTENTS) {
     if (partial_start && common_root->contains(partial_start)) {
       // FIXME: We should not continue if we have an earlier error.
       exception_state.ClearException();
       setStart(partial_start->parentNode(), partial_start->NodeIndex() + 1,
                exception_state);
     } else if (partial_end && common_root->contains(partial_end)) {
@@ skipping 216 matching lines @@
     exception_state.ThrowTypeError("The node provided is null.");
     return;
   }
 
   // HierarchyRequestError: Raised if the container of the start of the Range is
   // of a type that does not allow children of the type of newNode or if newNode
   // is an ancestor of the container.
 
   // an extra one here - if a text node is going to split, it must have a parent
   // to insert into
-  bool start_is_text = start_.Container()->IsTextNode();
-  if (start_is_text && !start_.Container()->parentNode()) {
+  bool start_is_text = start_.Container().IsTextNode();
+  if (start_is_text && !start_.Container().parentNode()) {
     exception_state.ThrowDOMException(kHierarchyRequestError,
                                       "This operation would split a text node, "
                                       "but there's no parent into which to "
                                       "insert.");
     return;
   }
 
   // In the case where the container is a text node, we check against the
   // container's parent, because text nodes get split up upon insertion.
   Node* check_against;
   if (start_is_text)
-    check_against = start_.Container()->parentNode();
+    check_against = start_.Container().parentNode();
   else
-    check_against = start_.Container();
+    check_against = &start_.Container();
 
   Node::NodeType new_node_type = new_node->getNodeType();
   int num_new_children;
   if (new_node_type == Node::kDocumentFragmentNode &&
       !new_node->IsShadowRoot()) {
     // check each child node, not the DocumentFragment itself
     num_new_children = 0;
     for (Node* c = ToDocumentFragment(new_node)->FirstChild(); c;
          c = c->nextSibling()) {
       if (!check_against->ChildTypeAllowed(c->getNodeType())) {
         exception_state.ThrowDOMException(
             kHierarchyRequestError,
             "The node to be inserted contains a '" + c->nodeName() +
                 "' node, which may not be inserted here.");
         return;
       }
       ++num_new_children;
     }
   } else {
     num_new_children = 1;
     if (!check_against->ChildTypeAllowed(new_node_type)) {
       exception_state.ThrowDOMException(
           kHierarchyRequestError,
           "The node to be inserted is a '" + new_node->nodeName() +
               "' node, which may not be inserted here.");
       return;
     }
   }
 
-  for (Node& node : NodeTraversal::InclusiveAncestorsOf(*start_.Container())) {
+  for (Node& node : NodeTraversal::InclusiveAncestorsOf(start_.Container())) {
     if (node == new_node) {
       exception_state.ThrowDOMException(kHierarchyRequestError,
                                         "The node to be inserted contains the "
                                         "insertion point; it may not be "
                                         "inserted into itself.");
       return;
     }
   }
 
   // InvalidNodeTypeError: Raised if newNode is an Attr, Entity, Notation,
@@ skipping 14 matching lines @@
                                           "here.");
         return;
       }
       break;
   }
 
   EventQueueScope scope;
   bool collapsed = start_ == end_;
   Node* container = nullptr;
   if (start_is_text) {
-    container = start_.Container();
+    container = &start_.Container();
     Text* new_text =
         ToText(container)->splitText(start_.Offset(), exception_state);
     if (exception_state.HadException())
       return;
 
-    container = start_.Container();
+    container = &start_.Container();
     container->parentNode()->InsertBefore(new_node, new_text, exception_state);
     if (exception_state.HadException())
       return;
 
     if (collapsed) {
       // Some types of events don't support EventQueueScope.  Given
       // circumstance may mutate the tree so newText->parentNode() may
       // become null.
       if (!new_text->parentNode()) {
         exception_state.ThrowDOMException(
@@ skipping 12 matching lines @@
       // The insertion will do nothing, but we need to extend the range to
       // include the inserted nodes.
       Node* first_child = (new_node_type == Node::kDocumentFragmentNode)
                               ? ToDocumentFragment(new_node)->FirstChild()
                               : new_node;
       DCHECK(first_child);
       start_.SetToBeforeChild(*first_child);
       return;
     }
 
-    container = start_.Container();
+    container = &start_.Container();
     Node* reference_node = NodeTraversal::ChildAt(*container, start_.Offset());
     // TODO(tkent): The following check must be unnecessary if we follow the
     // algorithm defined in the specification.
     // https://dom.spec.whatwg.org/#concept-range-insert
     if (new_node != reference_node) {
       container->insertBefore(new_node, reference_node, exception_state);
       if (exception_state.HadException())
         return;
     }
 
@@ skipping 34 matching lines @@
                        .SetEmitsObjectReplacementCharacter(true)
                        .Build());
 }
 
 DocumentFragment* Range::createContextualFragment(
     const String& markup,
     ExceptionState& exception_state) {
   // Algorithm:
   // http://domparsing.spec.whatwg.org/#extensions-to-the-range-interface
 
-  Node* node = start_.Container();
+  Node* node = &start_.Container();
 
   // Step 1.
   Element* element;
   if (!start_.Offset() &&
       (node->IsDocumentNode() || node->IsDocumentFragment()))
     element = nullptr;
   else if (node->IsElementNode())
     element = ToElement(node);
   else
     element = node->parentElement();
@@ skipping 142 matching lines @@
     case Node::kProcessingInstructionNode:
     case Node::kTextNode:
       exception_state.ThrowDOMException(
           kInvalidNodeTypeError,
           "The node provided is of type '" + n->nodeName() + "'.");
       return;
   }
 }
 
 Range* Range::cloneRange() const {
-  return Range::Create(*owner_document_.Get(), start_.Container(),
-                       start_.Offset(), end_.Container(), end_.Offset());
+  return Range::Create(*owner_document_.Get(), &start_.Container(),
+                       start_.Offset(), &end_.Container(), end_.Offset());
 }
 
 void Range::setStartAfter(Node* ref_node, ExceptionState& exception_state) {
   CheckNodeBA(ref_node, exception_state);
   if (exception_state.HadException())
     return;
 
   setStart(ref_node->parentNode(), ref_node->NodeIndex() + 1, exception_state);
 }
 
@@ skipping 102 matching lines @@
       case Node::kDocumentNode:
       case Node::kElementNode:
       case Node::kProcessingInstructionNode:
       case Node::kTextNode:
         break;
       case Node::kDocumentTypeNode:
         return false;
     }
   }
 
-  RangeBoundaryPoint start_boundary_point(ref_node);
+  RangeBoundaryPoint start_boundary_point(*ref_node);
   start_boundary_point.SetToStartOfNode(*ref_node);
   start = start_boundary_point.ToPosition();
-  RangeBoundaryPoint end_boundary_point(ref_node);
+  RangeBoundaryPoint end_boundary_point(*ref_node);
   end_boundary_point.SetToEndOfNode(*ref_node);
   end = end_boundary_point.ToPosition();
   return true;
 }
 
 // https://dom.spec.whatwg.org/#dom-range-surroundcontents
 void Range::surroundContents(Node* new_parent,
                              ExceptionState& exception_state) {
   if (!new_parent) {
     // FIXME: Generated bindings code never calls with null, and neither should
     // other callers!
     exception_state.ThrowTypeError("The node provided is null.");
     return;
   }
 
   // 1. If a non-Text node is partially contained in the context object, then
   // throw an InvalidStateError.
-  Node* start_non_text_container = start_.Container();
+  Node* start_non_text_container = &start_.Container();
   if (start_non_text_container->getNodeType() == Node::kTextNode)
     start_non_text_container = start_non_text_container->parentNode();
-  Node* end_non_text_container = end_.Container();
+  Node* end_non_text_container = &end_.Container();
   if (end_non_text_container->getNodeType() == Node::kTextNode)
     end_non_text_container = end_non_text_container->parentNode();
   if (start_non_text_container != end_non_text_container) {
     exception_state.ThrowDOMException(
         kInvalidStateError,
         "The Range has partially selected a non-Text node.");
     return;
   }
 
   // 2. If newParent is a Document, DocumentType, or DocumentFragment node, then
@@ skipping 61 matching lines @@
   for (Node* n = FirstNode(); n != past_last; n = NodeTraversal::Next(*n)) {
     if (n->IsDocumentTypeNode()) {
       exception_state.ThrowDOMException(kHierarchyRequestError,
                                         "The Range contains a doctype node.");
       return;
     }
   }
 }
 
 Node* Range::FirstNode() const {
-  if (start_.Container()->IsCharacterDataNode())
-    return start_.Container();
-  if (Node* child =
-          NodeTraversal::ChildAt(*start_.Container(), start_.Offset()))
+  if (start_.Container().IsCharacterDataNode())
+    return &start_.Container();
+  if (Node* child = NodeTraversal::ChildAt(start_.Container(), start_.Offset()))
     return child;
   if (!start_.Offset())
-    return start_.Container();
-  return NodeTraversal::NextSkippingChildren(*start_.Container());
+    return &start_.Container();
+  return NodeTraversal::NextSkippingChildren(start_.Container());
 }
 
 Node* Range::PastLastNode() const {
-  if (end_.Container()->IsCharacterDataNode())
-    return NodeTraversal::NextSkippingChildren(*end_.Container());
-  if (Node* child = NodeTraversal::ChildAt(*end_.Container(), end_.Offset()))
+  if (end_.Container().IsCharacterDataNode())
+    return NodeTraversal::NextSkippingChildren(end_.Container());
+  if (Node* child = NodeTraversal::ChildAt(end_.Container(), end_.Offset()))
     return child;
-  return NodeTraversal::NextSkippingChildren(*end_.Container());
+  return NodeTraversal::NextSkippingChildren(end_.Container());
 }
 
 IntRect Range::BoundingBox() const {
   IntRect result;
   Vector<IntRect> rects;
   TextRects(rects);
   for (const IntRect& rect : rects)
     result.Unite(rect);
   return result;
 }
 
 void Range::TextRects(Vector<IntRect>& rects, bool use_selection_height) const {
-  Node* start_container = start_.Container();
+  Node* start_container = &start_.Container();
   DCHECK(start_container);
-  Node* end_container = end_.Container();
+  Node* end_container = &end_.Container();
   DCHECK(end_container);
 
   Node* stop_node = PastLastNode();
   for (Node* node = FirstNode(); node != stop_node;
        node = NodeTraversal::Next(*node)) {
     LayoutObject* r = node->GetLayoutObject();
     if (!r || !r->IsText())
       continue;
     LayoutText* layout_text = ToLayoutText(r);
     unsigned start_offset = node == start_container ? start_.Offset() : 0;
     unsigned end_offset = node == end_container
                               ? end_.Offset()
                               : std::numeric_limits<unsigned>::max();
     layout_text->AbsoluteRectsForRange(rects, start_offset, end_offset,
                                        use_selection_height);
   }
 }
 
 void Range::TextQuads(Vector<FloatQuad>& quads,
                       bool use_selection_height) const {
-  Node* start_container = start_.Container();
+  Node* start_container = &start_.Container();
   DCHECK(start_container);
-  Node* end_container = end_.Container();
+  Node* end_container = &end_.Container();
   DCHECK(end_container);
 
   Node* stop_node = PastLastNode();
   for (Node* node = FirstNode(); node != stop_node;
        node = NodeTraversal::Next(*node)) {
     LayoutObject* r = node->GetLayoutObject();
     if (!r || !r->IsText())
       continue;
     LayoutText* layout_text = ToLayoutText(r);
     unsigned start_offset = node == start_container ? start_.Offset() : 0;
@@ skipping 17 matching lines @@
 static inline void BoundaryNodeChildrenWillBeRemoved(
     RangeBoundaryPoint& boundary,
     ContainerNode& container) {
   for (Node* node_to_be_removed = container.FirstChild(); node_to_be_removed;
        node_to_be_removed = node_to_be_removed->nextSibling()) {
     if (boundary.ChildBefore() == node_to_be_removed) {
       boundary.SetToStartOfNode(container);
       return;
     }
 
-    for (Node* n = boundary.Container(); n; n = n->parentNode()) {
+    for (Node* n = &boundary.Container(); n; n = n->parentNode()) {
       if (n == node_to_be_removed) {
         boundary.SetToStartOfNode(container);
         return;
       }
     }
   }
 }
 
 void Range::NodeChildrenWillBeRemoved(ContainerNode& container) {
   DCHECK_EQ(container.GetDocument(), owner_document_);
   BoundaryNodeChildrenWillBeRemoved(start_, container);
   BoundaryNodeChildrenWillBeRemoved(end_, container);
 }
 
 static inline void BoundaryNodeWillBeRemoved(RangeBoundaryPoint& boundary,
                                              Node& node_to_be_removed) {
   if (boundary.ChildBefore() == node_to_be_removed) {
     boundary.ChildBeforeWillBeRemoved();
     return;
   }
 
-  for (Node* n = boundary.Container(); n; n = n->parentNode()) {
+  for (Node* n = &boundary.Container(); n; n = n->parentNode()) {
     if (n == node_to_be_removed) {
       boundary.SetToBeforeChild(node_to_be_removed);
       return;
     }
   }
 }
 
 void Range::NodeWillBeRemoved(Node& node) {
   DCHECK_EQ(node.GetDocument(), owner_document_);
   DCHECK_NE(node, owner_document_.Get());
@@ skipping 45 matching lines @@
 void Range::DidRemoveText(Node* text, unsigned offset, unsigned length) {
   DCHECK(text);
   DCHECK_EQ(text->GetDocument(), owner_document_);
   BoundaryTextRemoved(start_, text, offset, length);
   BoundaryTextRemoved(end_, text, offset, length);
 }
 
 static inline void BoundaryTextNodesMerged(RangeBoundaryPoint& boundary,
                                            const NodeWithIndex& old_node,
                                            unsigned offset) {
-  if (boundary.Container() == old_node.GetNode())
-    boundary.Set(old_node.GetNode().previousSibling(),
-                 boundary.Offset() + offset, 0);
-  else if (boundary.Container() == old_node.GetNode().parentNode() &&
-           boundary.Offset() == static_cast<unsigned>(old_node.Index()))
-    boundary.Set(old_node.GetNode().previousSibling(), offset, 0);
+  if (boundary.Container() == old_node.GetNode()) {
+    Node* const previous_sibling = old_node.GetNode().previousSibling();
+    DCHECK(previous_sibling);
+    boundary.Set(*previous_sibling, boundary.Offset() + offset, 0);
+  } else if (boundary.Container() == old_node.GetNode().parentNode() &&
+             boundary.Offset() == static_cast<unsigned>(old_node.Index())) {
+    Node* const previous_sibling = old_node.GetNode().previousSibling();
+    DCHECK(previous_sibling);
+    boundary.Set(*previous_sibling, offset, 0);
+  }
 }
 
 void Range::DidMergeTextNodes(const NodeWithIndex& old_node, unsigned offset) {
   DCHECK_EQ(old_node.GetNode().GetDocument(), owner_document_);
   DCHECK(old_node.GetNode().parentNode());
   DCHECK(old_node.GetNode().IsTextNode());
   DCHECK(old_node.GetNode().previousSibling());
   DCHECK(old_node.GetNode().previousSibling()->IsTextNode());
   BoundaryTextNodesMerged(start_, old_node, offset);
   BoundaryTextNodesMerged(end_, old_node, offset);
 }
 
 void Range::UpdateOwnerDocumentIfNeeded() {
-  DCHECK(start_.Container());
-  DCHECK(end_.Container());
-  Document& new_document = start_.Container()->GetDocument();
-  DCHECK_EQ(new_document, end_.Container()->GetDocument());
+  Document& new_document = start_.Container().GetDocument();
+  DCHECK_EQ(new_document, end_.Container().GetDocument());
   if (new_document == owner_document_)
     return;
   owner_document_->DetachRange(this);
   owner_document_ = &new_document;
   owner_document_->AttachRange(this);
 }
 
 static inline void BoundaryTextNodeSplit(RangeBoundaryPoint& boundary,
                                          const Text& old_node) {
-  Node* boundary_container = boundary.Container();
   unsigned boundary_offset = boundary.Offset();
-  if (boundary.ChildBefore() == &old_node)
-    boundary.Set(boundary_container, boundary_offset + 1,
+  if (boundary.ChildBefore() == &old_node) {
+    boundary.Set(boundary.Container(), boundary_offset + 1,
                  old_node.nextSibling());
-  else if (boundary.Container() == &old_node &&
-           boundary_offset > old_node.length())
-    boundary.Set(old_node.nextSibling(), boundary_offset - old_node.length(),
-                 0);
+  } else if (boundary.Container() == &old_node &&
+             boundary_offset > old_node.length()) {
+    Node* const next_sibling = old_node.nextSibling();
+    DCHECK(next_sibling);
+    boundary.Set(*next_sibling, boundary_offset - old_node.length(), 0);
+  }
 }
 
 void Range::DidSplitTextNode(const Text& old_node) {
   DCHECK_EQ(old_node.GetDocument(), owner_document_);
   DCHECK(old_node.parentNode());
   DCHECK(old_node.nextSibling());
   DCHECK(old_node.nextSibling()->IsTextNode());
   BoundaryTextNodeSplit(start_, old_node);
   BoundaryTextNodeSplit(end_, old_node);
   DCHECK(BoundaryPointsValid());
@@ skipping 34 matching lines @@
   GetBorderAndTextQuads(quads);
 
   return ClientRectList::Create(quads);
 }
 
 ClientRect* Range::getBoundingClientRect() const {
   return ClientRect::Create(BoundingRect());
 }
 
 void Range::GetBorderAndTextQuads(Vector<FloatQuad>& quads) const {
-  Node* start_container = start_.Container();
-  Node* end_container = end_.Container();
+  Node* start_container = &start_.Container();
+  Node* end_container = &end_.Container();
   Node* stop_node = PastLastNode();
 
   HeapHashSet<Member<Node>> node_set;
   for (Node* node = FirstNode(); node != stop_node;
        node = NodeTraversal::Next(*node)) {
     if (node->IsElementNode())
       node_set.insert(node);
   }
 
   for (Node* node = FirstNode(); node != stop_node;
@@ skipping 104 matching lines @@
                      .Data()
               << "start offset: " << range->startOffset()
               << ", end offset: " << range->endOffset();
   } else {
     LOG(INFO) << "Cannot show tree if range is null, or if boundary points are "
                  "invalid.";
   }
 }
 
 #endif