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

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

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 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
@@ skipping 66 matching lines @@
   if (!IsEnclosedBy(position, *shadow_host))
     return nullptr;
   return IsSelectionBoundary(*shadow_host) ? shadow_host : nullptr;
 }
 
 PositionInFlatTree AdjustPositionInFlatTreeForStart(
     const PositionInFlatTree& position,
     Node* shadow_host) {
   if (IsEnclosedBy(position, *shadow_host)) {
     if (position.IsBeforeChildren())
-      return PositionInFlatTree::BeforeNode(shadow_host);
+      return PositionInFlatTree::BeforeNode(*shadow_host);
     return PositionInFlatTree::AfterNode(shadow_host);
   }
 
   // We use |firstChild|'s after instead of beforeAllChildren for backward
   // compatibility. The positions are same but the anchors would be different,
   // and selection painting uses anchor nodes.
   if (Node* first_child = FlatTreeTraversal::FirstChild(*shadow_host))
-    return PositionInFlatTree::BeforeNode(first_child);
+    return PositionInFlatTree::BeforeNode(*first_child);
   return PositionInFlatTree();
 }
 
 Position AdjustPositionForEnd(const Position& current_position,
                               Node* start_container_node) {
   TreeScope& tree_scope = start_container_node->GetTreeScope();
 
   DCHECK(current_position.ComputeContainerNode()->GetTreeScope() != tree_scope);
 
   if (Node* ancestor = tree_scope.AncestorInThisScope(
           current_position.ComputeContainerNode())) {
     if (ancestor->contains(start_container_node))
       return Position::AfterNode(ancestor);
-    return Position::BeforeNode(ancestor);
+    return Position::BeforeNode(*ancestor);
   }
 
   if (Node* last_child = tree_scope.RootNode().lastChild())
     return Position::AfterNode(last_child);
 
   return Position();
 }
 
 PositionInFlatTree AdjustPositionInFlatTreeForEnd(
     const PositionInFlatTree& position,
     Node* shadow_host) {
   if (IsEnclosedBy(position, *shadow_host)) {
     if (position.IsAfterChildren())
       return PositionInFlatTree::AfterNode(shadow_host);
-    return PositionInFlatTree::BeforeNode(shadow_host);
+    return PositionInFlatTree::BeforeNode(*shadow_host);
   }
 
   // We use |lastChild|'s after instead of afterAllChildren for backward
   // compatibility. The positions are same but the anchors would be different,
   // and selection painting uses anchor nodes.
   if (Node* last_child = FlatTreeTraversal::LastChild(*shadow_host))
     return PositionInFlatTree::AfterNode(last_child);
   return PositionInFlatTree();
 }
 
 Position AdjustPositionForStart(const Position& current_position,
                                 Node* end_container_node) {
   TreeScope& tree_scope = end_container_node->GetTreeScope();
 
   DCHECK(current_position.ComputeContainerNode()->GetTreeScope() != tree_scope);
 
   if (Node* ancestor = tree_scope.AncestorInThisScope(
           current_position.ComputeContainerNode())) {
     if (ancestor->contains(end_container_node))
-      return Position::BeforeNode(ancestor);
+      return Position::BeforeNode(*ancestor);
     return Position::AfterNode(ancestor);
   }
 
   if (Node* first_child = tree_scope.RootNode().firstChild())
-    return Position::BeforeNode(first_child);
+    return Position::BeforeNode(*first_child);
 
   return Position();
 }
 
 }  // namespace
 
 void SelectionAdjuster::AdjustSelectionToAvoidCrossingShadowBoundaries(
     VisibleSelection* selection) {
   // Note: |m_selectionType| isn't computed yet.
   DCHECK(selection->Base().IsNotNull());
@@ skipping 43 matching lines @@
   }
   Node* const shadow_host =
       shadow_host_end ? shadow_host_end : shadow_host_start;
   const PositionInFlatTree& new_start =
       AdjustPositionInFlatTreeForStart(selection->Start(), shadow_host);
   selection->extent_ = new_start;
   selection->start_ = new_start;
 }
 
 }  // namespace blink