Simplify the usage of PositionWithAffinity

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

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 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
@@ skipping 164 matching lines @@
 static PositionWithAffinityTemplate<Strategy> honorEditingBoundaryAtOrBefore(
     const PositionWithAffinityTemplate<Strategy>& pos,
     const PositionTemplate<Strategy>& anchor) {
   if (pos.isNull())
     return pos;
 
   ContainerNode* highestRoot = highestEditableRoot(anchor);
 
   // Return empty position if |pos| is not somewhere inside the editable
   // region containing this position
-  if (highestRoot && !pos.position().anchorNode()->isDescendantOf(highestRoot))
+  if (highestRoot && !pos.anchorNode()->isDescendantOf(highestRoot))
     return PositionWithAffinityTemplate<Strategy>();
 
   // Return |pos| itself if the two are from the very same editable region, or
   // both are non-editable
   // TODO(yosin) In the non-editable case, just because the new position is
   // non-editable doesn't mean movement to it is allowed.
   // |VisibleSelection::adjustForEditableContent()| has this problem too.
   if (highestEditableRoot(pos.position()) == highestRoot)
     return pos;
 
@@ skipping 1227 matching lines @@
     const VisiblePositionInFlatTree& currentPosition) {
   return logicalEndOfLineAlgorithm<EditingInFlatTreeStrategy>(currentPosition);
 }
 
 template <typename Strategy>
 bool inSameLineAlgorithm(
     const PositionWithAffinityTemplate<Strategy>& position1,
     const PositionWithAffinityTemplate<Strategy>& position2) {
   if (position1.isNull() || position2.isNull())
     return false;
-  DCHECK_EQ(position1.position().document(), position2.position().document());
-  DCHECK(!position1.position().document()->needsLayoutTreeUpdate());
+  DCHECK_EQ(position1.document(), position2.document());
+  DCHECK(!position1.document()->needsLayoutTreeUpdate());
 
   PositionWithAffinityTemplate<Strategy> startOfLine1 = startOfLine(position1);
   PositionWithAffinityTemplate<Strategy> startOfLine2 = startOfLine(position2);
   if (startOfLine1 == startOfLine2)
     return true;
   PositionTemplate<Strategy> canonicalized1 =
       canonicalPositionOf(startOfLine1.position());
   if (canonicalized1 == startOfLine2.position())
     return true;
   return canonicalized1 == canonicalPositionOf(startOfLine2.position());
@@ skipping 1192 matching lines @@
                                            TextAffinity affinity,
                                            TextDirection primaryDirection) {
   return computeInlineBoxPositionTemplate<EditingInFlatTreeStrategy>(
       position, affinity, primaryDirection);
 }
 
 template <typename Strategy>
 LayoutRect localCaretRectOfPositionTemplate(
     const PositionWithAffinityTemplate<Strategy>& position,
     LayoutObject*& layoutObject) {
-  if (position.position().isNull()) {
+  if (position.isNull()) {
     layoutObject = nullptr;
     return LayoutRect();
   }
-  Node* node = position.position().anchorNode();
+  Node* node = position.anchorNode();
 
   layoutObject = node->layoutObject();
   if (!layoutObject)
     return LayoutRect();
 
   InlineBoxPosition boxPosition =
       computeInlineBoxPosition(position.position(), position.affinity());
 
   if (boxPosition.inlineBox)
     layoutObject = LineLayoutAPIShim::layoutObjectFrom(
@@ skipping 1344 matching lines @@
   if (visiblePosition.isNull())
     return VisiblePositionInFlatTree();
   visiblePosition.deepEquivalent()
       .document()
       ->updateStyleAndLayoutIgnorePendingStylesheets();
   return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(
       visiblePosition.deepEquivalent(), rule);
 }
 
 }  // namespace blink