Let RangeboundaryPoint::container_node_ be reference.

third_party/WebKit/Source/core/dom/RangeBoundaryPoint.h

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 18 matching lines @@
 #include "core/dom/Node.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/editing/Position.h"
 
 namespace blink {
 
 class RangeBoundaryPoint {
   DISALLOW_NEW();
 
  public:
-  explicit RangeBoundaryPoint(Node* container);
+  explicit RangeBoundaryPoint(Node& container);
 
   explicit RangeBoundaryPoint(const RangeBoundaryPoint&);
 
   bool IsConnected() const;
   const Position ToPosition() const;
 
-  Node* Container() const;
+  Node& Container() const;
   unsigned Offset() const;
   Node* ChildBefore() const;
 
-  void Set(Node* container, unsigned offset, Node* child_before);
+  void Set(Node& container, unsigned offset, Node* child_before);
   void SetOffset(unsigned);
 
   void SetToBeforeChild(Node&);
   void SetToStartOfNode(Node&);
   void SetToEndOfNode(Node&);
 
   void ChildBeforeWillBeRemoved();
   void InvalidateOffset();
   void MarkValid() const;
 
   DEFINE_INLINE_TRACE() {
     visitor->Trace(container_node_);
     visitor->Trace(child_before_boundary_);
   }
 
  private:
   uint64_t DomTreeVersion() const;
   void EnsureOffsetIsValid() const;
   bool IsOffsetValid() const;
 
   static const unsigned kInvalidOffset = static_cast<unsigned>(-1);
 
   Member<Node> container_node_;
   Member<Node> child_before_boundary_;
   mutable uint64_t dom_tree_version_;
   mutable unsigned offset_in_container_;
 };
 
-inline RangeBoundaryPoint::RangeBoundaryPoint(Node* container)
+inline RangeBoundaryPoint::RangeBoundaryPoint(Node& container)
     : container_node_(container),
       child_before_boundary_(nullptr),
       dom_tree_version_(DomTreeVersion()),
       offset_in_container_(0) {}
 
 inline RangeBoundaryPoint::RangeBoundaryPoint(const RangeBoundaryPoint& other)
     : container_node_(other.Container()),
       child_before_boundary_(other.ChildBefore()),
       dom_tree_version_(other.dom_tree_version_),
       offset_in_container_(other.Offset()) {}
 
-inline Node* RangeBoundaryPoint::Container() const {
-  return container_node_.Get();
+inline Node& RangeBoundaryPoint::Container() const {
+  return *container_node_;
 }
 
 inline Node* RangeBoundaryPoint::ChildBefore() const {
   return child_before_boundary_.Get();
 }
 
 inline uint64_t RangeBoundaryPoint::DomTreeVersion() const {
   return container_node_->GetDocument().DomTreeVersion();
 }
 
@@ skipping 27 matching lines @@
   // TODO(yosin): We should return |Position::beforeAnchor| when
   // |m_containerNode| isn't |Text| node.
   return Position(container_node_.Get(), offset_in_container_);
 }
 
 inline unsigned RangeBoundaryPoint::Offset() const {
   EnsureOffsetIsValid();
   return offset_in_container_;
 }
 
-inline void RangeBoundaryPoint::Set(Node* container,
+inline void RangeBoundaryPoint::Set(Node& container,
                                     unsigned offset,
                                     Node* child_before) {
-  DCHECK(container);
   DCHECK_GE(offset, 0u);
   DCHECK_EQ(child_before,
-            offset ? NodeTraversal::ChildAt(*container, offset - 1) : 0);
+            offset ? NodeTraversal::ChildAt(container, offset - 1) : 0);
   container_node_ = container;
   offset_in_container_ = offset;
   child_before_boundary_ = child_before;
   MarkValid();
 }
 
 inline void RangeBoundaryPoint::SetOffset(unsigned offset) {
   DCHECK(container_node_);
   DCHECK(container_node_->IsCharacterDataNode());
   DCHECK_GE(offset_in_container_, 0u);
@@ skipping 59 matching lines @@
   } else {
     if (a.Offset() != b.Offset())
       return false;
   }
   return true;
 }
 
 }  // namespace blink
 
 #endif