Make Position::BeforeNode() to take const Node& instead of Node*

third_party/WebKit/Source/core/editing/EditingUtilities.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 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 312 matching lines @@
   return ComparePositions(a.DeepEquivalent(), b.DeepEquivalent());
 }
 
 bool IsNodeFullyContained(const EphemeralRange& range, Node& node) {
   if (range.IsNull())
     return false;
 
   if (!NodeTraversal::CommonAncestor(*range.StartPosition().AnchorNode(), node))
     return false;
 
-  return range.StartPosition() <= Position::BeforeNode(&node) &&
+  return range.StartPosition() <= Position::BeforeNode(node) &&
          Position::AfterNode(&node) <= range.EndPosition();
 }
 
 // TODO(editing-dev): We should implement real version which refers
 // "user-select" CSS property.
 // TODO(editing-dev): We should make |SelectionAdjuster| to use this funciton
 // instead of |isSelectionBondary()|.
 bool IsUserSelectContain(const Node& node) {
   return isHTMLTextAreaElement(node) || isHTMLInputElement(node) ||
          isHTMLSelectElement(node);
@@ skipping 499 matching lines @@
     const PositionTemplate<Strategy>& position,
     PositionMoveType move_type) {
   Node* const node = position.AnchorNode();
   if (!node)
     return position;
 
   const int offset = position.ComputeEditingOffset();
 
   if (offset > 0) {
     if (EditingIgnoresContent(*node))
-      return PositionTemplate<Strategy>::BeforeNode(node);
+      return PositionTemplate<Strategy>::BeforeNode(*node);
     if (Node* child = Strategy::ChildAt(*node, offset - 1))
       return PositionTemplate<Strategy>::LastPositionInOrAfterNode(child);
 
     // There are two reasons child might be 0:
     //   1) The node is node like a text node that is not an element, and
     //      therefore has no children. Going backward one character at a
     //      time is correct.
     //   2) The old offset was a bogus offset like (<br>, 1), and there is
     //      no child. Going from 1 to 0 is correct.
     switch (move_type) {
       case PositionMoveType::kCodeUnit:
         return PositionTemplate<Strategy>(node, offset - 1);
       case PositionMoveType::kBackwardDeletion:
         return PositionTemplate<Strategy>(
             node, PreviousBackwardDeletionOffsetOf(node, offset));
       case PositionMoveType::kGraphemeCluster:
         return PositionTemplate<Strategy>(
             node, PreviousGraphemeBoundaryOf(node, offset));
       default:
         NOTREACHED() << "Unhandled moveType: " << move_type;
     }
   }
 
   if (ContainerNode* parent = Strategy::Parent(*node)) {
     if (EditingIgnoresContent(*parent))
-      return PositionTemplate<Strategy>::BeforeNode(parent);
+      return PositionTemplate<Strategy>::BeforeNode(*parent);
     // TODO(yosin) We should use |Strategy::index(Node&)| instead of
     // |Node::nodeIndex()|.
     return PositionTemplate<Strategy>(parent, node->NodeIndex());
   }
   return position;
 }
 
 Position PreviousPositionOf(const Position& position,
                             PositionMoveType move_type) {
   return PreviousPositionOfAlgorithm<EditingStrategy>(position, move_type);
@@ skipping 1289 matching lines @@
         return InputType::kDeleteSoftLineBackward;
       if (granularity == kParagraphBoundary)
         return InputType::kDeleteHardLineBackward;
       return InputType::kDeleteContentBackward;
     default:
       return InputType::kNone;
   }
 }
 
 }  // namespace blink