Get rid of a redundant argument DOWNSTREAM from VisiblePosition constructor call sites

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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 501 matching lines @@
         it.advance();
     }
     if (needMoreContext) {
         // The last search returned the beginning of the buffer and asked for more context,
         // but there is no earlier text. Force a search with what's available.
         next = searchFunction(string.data(), string.size(), string.size() - suffixLength, DontHaveMoreContext, needMoreContext);
         ASSERT(!needMoreContext);
     }
 
     if (!next)
-        return VisiblePosition(it.atEnd() ? it.startPosition() : pos, DOWNSTREAM);
+        return VisiblePosition(it.atEnd() ? it.startPosition() : pos);
 
     Node* node = it.startContainer();
     if (node->isTextNode() && static_cast<int>(next) <= node->maxCharacterOffset()) {
         // The next variable contains a usable index into a text node
-        return VisiblePosition(Position(node, next), DOWNSTREAM);
+        return VisiblePosition(Position(node, next));
     }
 
     // Use the character iterator to translate the next value into a DOM position.
     BackwardsCharacterIterator charIt(start, end);
     charIt.advance(string.size() - suffixLength - next);
     // FIXME: charIt can get out of shadow host.
-    return VisiblePosition(charIt.endPosition(), DOWNSTREAM);
+    return VisiblePosition(charIt.endPosition());
 }
 
 static VisiblePosition nextBoundary(const VisiblePosition& c, BoundarySearchFunction searchFunction)
 {
     Position pos = c.deepEquivalent();
     Node* boundary = pos.parentEditingBoundary();
     if (!boundary)
         return VisiblePosition();
 
     Document& d = boundary->document();
@@ skipping 456 matching lines @@
             return VisiblePosition(positionInParentBeforeNode(*node));
         return VisiblePosition(layoutObject.positionForPoint(pointInLine));
     }
 
     // Could not find a previous line. This means we must already be on the first line.
     // Move to the start of the content in this block, which effectively moves us
     // to the start of the line we're on.
     Element* rootElement = node->hasEditableStyle(editableType) ? node->rootEditableElement(editableType) : node->document().documentElement();
     if (!rootElement)
         return VisiblePosition();
-    return VisiblePosition(firstPositionInNode(rootElement), DOWNSTREAM);
+    return VisiblePosition(firstPositionInNode(rootElement));
 }
 
 VisiblePosition nextLinePosition(const VisiblePosition &visiblePosition, LayoutUnit lineDirectionPoint, EditableType editableType)
 {
     Position p = visiblePosition.deepEquivalent();
     Node* node = p.anchorNode();
 
     if (!node)
         return VisiblePosition();
 
@@ skipping 35 matching lines @@
             return VisiblePosition(positionInParentBeforeNode(*node));
         return VisiblePosition(layoutObject.positionForPoint(pointInLine));
     }
 
     // Could not find a next line. This means we must already be on the last line.
     // Move to the end of the content in this block, which effectively moves us
     // to the end of the line we're on.
     Element* rootElement = node->hasEditableStyle(editableType) ? node->rootEditableElement(editableType) : node->document().documentElement();
     if (!rootElement)
         return VisiblePosition();
-    return VisiblePosition(lastPositionInNode(rootElement), DOWNSTREAM);
+    return VisiblePosition(lastPositionInNode(rootElement));
 }
 
 // ---------
 
 static unsigned startSentenceBoundary(const UChar* characters, unsigned length, unsigned, BoundarySearchContextAvailability, bool&)
 {
     TextBreakIterator* iterator = sentenceBreakIterator(characters, length);
     // FIXME: The following function can return -1; we don't handle that.
     return iterator->preceding(length);
 }
@@ skipping 90 matching lines @@
             ASSERT_WITH_SECURITY_IMPLICATION(n->isTextNode());
             type = PositionAnchorType::OffsetInAnchor;
             if (style.preserveNewline()) {
                 LayoutText* text = toLayoutText(r);
                 int i = text->textLength();
                 int o = offset;
                 if (n == startNode && o < i)
                     i = max(0, o);
                 while (--i >= 0) {
                     if ((*text)[i] == '\n')
-                        return VisiblePosition(Position(toText(n), i + 1), DOWNSTREAM);
+                        return VisiblePosition(Position(toText(n), i + 1));
                 }
             }
             node = n;
             offset = 0;
             n = NodeTraversal::previousPostOrder(*n, startBlock);
         } else if (editingIgnoresContent(n) || isRenderedTableElement(n)) {
             node = n;
             type = PositionAnchorType::BeforeAnchor;
             n = n->previousSibling() ? n->previousSibling() : NodeTraversal::previousPostOrder(*n, startBlock);
         } else {
             n = NodeTraversal::previousPostOrder(*n, startBlock);
         }
     }
 
     if (type == PositionAnchorType::OffsetInAnchor)
-        return VisiblePosition(Position(node, offset), DOWNSTREAM);
+        return VisiblePosition(Position(node, offset));
 
-    return VisiblePosition(Position(node, type), DOWNSTREAM);
+    return VisiblePosition(Position(node, type));
 }
 
 VisiblePosition endOfParagraph(const VisiblePosition &c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     if (c.isNull())
         return VisiblePosition();
 
     Position p = c.deepEquivalent();
     Node* startNode = p.anchorNode();
 
@@ skipping 37 matching lines @@
         // FIXME: We avoid returning a position where the layoutObject can't accept the caret.
         if (r->isText() && toLayoutText(r)->resolvedTextLength()) {
             ASSERT_WITH_SECURITY_IMPLICATION(n->isTextNode());
             int length = toLayoutText(r)->textLength();
             type = PositionAnchorType::OffsetInAnchor;
             if (style.preserveNewline()) {
                 LayoutText* text = toLayoutText(r);
                 int o = n == startNode ? offset : 0;
                 for (int i = o; i < length; ++i) {
                     if ((*text)[i] == '\n')
-                        return VisiblePosition(Position(toText(n), i), DOWNSTREAM);
+                        return VisiblePosition(Position(toText(n), i));
                 }
             }
             node = n;
             offset = r->caretMaxOffset();
             n = NodeTraversal::next(*n, stayInsideBlock);
         } else if (editingIgnoresContent(n) || isRenderedTableElement(n)) {
             node = n;
             type = PositionAnchorType::AfterAnchor;
             n = NodeTraversal::nextSkippingChildren(*n, stayInsideBlock);
         } else {
             n = NodeTraversal::next(*n, stayInsideBlock);
         }
     }
 
     if (type == PositionAnchorType::OffsetInAnchor)
-        return VisiblePosition(Position(node, offset), DOWNSTREAM);
+        return VisiblePosition(Position(node, offset));
 
-    return VisiblePosition(Position(node, type), DOWNSTREAM);
+    return VisiblePosition(Position(node, type));
 }
 
 // FIXME: isStartOfParagraph(startOfNextParagraph(pos)) is not always true
 VisiblePosition startOfNextParagraph(const VisiblePosition& visiblePosition)
 {
     VisiblePosition paragraphEnd(endOfParagraph(visiblePosition, CanSkipOverEditingBoundary));
     VisiblePosition afterParagraphEnd(paragraphEnd.next(CannotCrossEditingBoundary));
     // The position after the last position in the last cell of a table
     // is not the start of the next paragraph.
     if (isFirstPositionAfterTable(afterParagraphEnd))
@@ skipping 71 matching lines @@
     return pos.isNotNull() && pos.deepEquivalent() == endOfBlock(pos, CanCrossEditingBoundary).deepEquivalent();
 }
 
 // ---------
 
 VisiblePosition startOfDocument(const Node* node)
 {
     if (!node || !node->document().documentElement())
         return VisiblePosition();
 
-    return VisiblePosition(firstPositionInNode(node->document().documentElement()), DOWNSTREAM);
+    return VisiblePosition(firstPositionInNode(node->document().documentElement()));
 }
 
 VisiblePosition startOfDocument(const VisiblePosition &c)
 {
     return startOfDocument(c.deepEquivalent().anchorNode());
 }
 
 VisiblePosition endOfDocument(const Node* node)
 {
     if (!node || !node->document().documentElement())
         return VisiblePosition();
 
     Element* doc = node->document().documentElement();
-    return VisiblePosition(lastPositionInNode(doc), DOWNSTREAM);
+    return VisiblePosition(lastPositionInNode(doc));
 }
 
 VisiblePosition endOfDocument(const VisiblePosition &c)
 {
     return endOfDocument(c.deepEquivalent().anchorNode());
 }
 
 bool isStartOfDocument(const VisiblePosition &p)
 {
     return p.isNotNull() && p.previous(CanCrossEditingBoundary).isNull();
@@ skipping 206 matching lines @@
 
     if (previousRenderedEditable(position1.anchorNode()) == position2.anchorNode()
         && !renderedOffset1 && renderedOffset2 == caretMaxOffset(position2.anchorNode())) {
         return false;
     }
 
     return true;
 }
 
 }