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

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

 /*
  * Copyright (C) 2004, 2005, 2006, 2009 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 456 matching lines @@
 template <typename Strategy>
 PositionTemplate<Strategy> PositionTemplate<Strategy>::BeforeNode(
     const Node& anchor_node) {
   return PositionTemplate<Strategy>(&anchor_node,
                                     PositionAnchorType::kBeforeAnchor);
 }
 
 // static
 template <typename Strategy>
 PositionTemplate<Strategy> PositionTemplate<Strategy>::AfterNode(
-    Node* anchor_node) {
-  DCHECK(anchor_node);
-  return PositionTemplate<Strategy>(anchor_node,
+    const Node& anchor_node) {
+  return PositionTemplate<Strategy>(&anchor_node,
                                     PositionAnchorType::kAfterAnchor);
 }
 
 // static
 template <typename Strategy>
 int PositionTemplate<Strategy>::LastOffsetInNode(Node* node) {
   return node->IsCharacterDataNode()
              ? node->MaxCharacterOffset()
              : static_cast<int>(Strategy::CountChildren(*node));
 }
@@ skipping 28 matching lines @@
   return EditingIgnoresContent(*node) ? BeforeNode(*node)
                                       : FirstPositionInNode(node);
 }
 
 // static
 template <typename Strategy>
 PositionTemplate<Strategy>
 PositionTemplate<Strategy>::LastPositionInOrAfterNode(Node* node) {
   if (!node)
     return PositionTemplate<Strategy>();
-  return EditingIgnoresContent(*node) ? AfterNode(node)
+  return EditingIgnoresContent(*node) ? AfterNode(*node)
                                       : LastPositionInNode(node);
 }
 
 PositionInFlatTree ToPositionInFlatTree(const Position& pos) {
   if (pos.IsNull())
     return PositionInFlatTree();
 
   Node* const anchor = pos.AnchorNode();
   if (pos.IsOffsetInAnchor()) {
     if (anchor->IsCharacterDataNode())
@@ skipping 51 matching lines @@
   if (position.IsNull())
     return Position();
 
   Node* anchor_node = position.AnchorNode();
 
   switch (position.AnchorType()) {
     case PositionAnchorType::kAfterChildren:
       // FIXME: When anchorNode is <img>, assertion fails in the constructor.
       return Position(anchor_node, PositionAnchorType::kAfterChildren);
     case PositionAnchorType::kAfterAnchor:
-      return Position::AfterNode(anchor_node);
+      return Position::AfterNode(*anchor_node);
     case PositionAnchorType::kBeforeChildren:
       return Position(anchor_node, PositionAnchorType::kBeforeChildren);
     case PositionAnchorType::kBeforeAnchor:
       return Position::BeforeNode(*anchor_node);
     case PositionAnchorType::kOffsetInAnchor: {
       int offset = position.OffsetInContainerNode();
       if (anchor_node->IsCharacterDataNode())
         return Position(anchor_node, offset);
       Node* child = FlatTreeTraversal::ChildAt(*anchor_node, offset);
       if (child)
@@ skipping 104 matching lines @@
 }
 
 void showTree(const blink::Position* pos) {
   if (pos)
     pos->ShowTreeForThis();
   else
     LOG(INFO) << "Cannot showTree for <null>";
 }
 
 #endif