Make Position::BeforeNode() 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 69 matching lines @@
     return PositionTemplate<Strategy>(anchor_node,
                                       PositionAnchorType::kBeforeAnchor);
 
   // Note: |offset| can be >= 1, if |anchorNode| have child nodes, e.g.
   // using Node.appendChild() to add a child node TEXTAREA.
   DCHECK_GE(offset, 1);
   return PositionTemplate<Strategy>(anchor_node,
                                     PositionAnchorType::kAfterAnchor);
 }
 
+// TODO(editing-dev): Once we change type of |anchor_node_| to
+// |Member<const Node>|, we should get rid of |const_cast<Node*>()|.
+// See http://crbug.com/735327
 template <typename Strategy>
-PositionTemplate<Strategy>::PositionTemplate(Node* anchor_node,
+PositionTemplate<Strategy>::PositionTemplate(const Node* anchor_node,
                                              PositionAnchorType anchor_type)
-    : anchor_node_(anchor_node), offset_(0), anchor_type_(anchor_type) {
+    : anchor_node_(const_cast<Node*>(anchor_node)),
+      offset_(0),
+      anchor_type_(anchor_type) {
   if (!anchor_node_) {
     anchor_type_ = PositionAnchorType::kOffsetInAnchor;
     return;
   }
   if (anchor_node_->IsTextNode()) {
     DCHECK(anchor_type_ == PositionAnchorType::kBeforeAnchor ||
            anchor_type_ == PositionAnchorType::kAfterAnchor);
     return;
   }
   if (anchor_node_->IsDocumentNode()) {
@@ skipping 350 matching lines @@
 PositionTemplate<Strategy> PositionTemplate<Strategy>::InParentAfterNode(
     const Node& node) {
   DCHECK(node.parentNode()) << node;
   return PositionTemplate<Strategy>(Strategy::Parent(node),
                                     Strategy::Index(node) + 1);
 }
 
 // static
 template <typename Strategy>
 PositionTemplate<Strategy> PositionTemplate<Strategy>::BeforeNode(
-    Node* anchor_node) {
-  DCHECK(anchor_node);
-  return PositionTemplate<Strategy>(anchor_node,
+    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,
                                     PositionAnchorType::kAfterAnchor);
@@ skipping 27 matching lines @@
   return PositionTemplate<Strategy>(anchor_node,
                                     PositionAnchorType::kAfterChildren);
 }
 
 // static
 template <typename Strategy>
 PositionTemplate<Strategy>
 PositionTemplate<Strategy>::FirstPositionInOrBeforeNode(Node* node) {
   if (!node)
     return PositionTemplate<Strategy>();
-  return EditingIgnoresContent(*node) ? BeforeNode(node)
+  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)
@@ skipping 65 matching lines @@
 
   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);
     case PositionAnchorType::kBeforeChildren:
       return Position(anchor_node, PositionAnchorType::kBeforeChildren);
     case PositionAnchorType::kBeforeAnchor:
-      return Position::BeforeNode(anchor_node);
+      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)
         return Position(child->parentNode(), child->NodeIndex());
       if (!position.OffsetInContainerNode())
         return Position(anchor_node, PositionAnchorType::kBeforeChildren);
 
@@ skipping 100 matching lines @@
 }
 
 void showTree(const blink::Position* pos) {
   if (pos)
     pos->ShowTreeForThis();
   else
     LOG(INFO) << "Cannot showTree for <null>";
 }
 
 #endif