Prune deprecated functions from VisibleSelection and VisibleUnits

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 1842 matching lines @@
 }
 
 VisiblePositionInFlatTree startOfParagraph(
     const VisiblePositionInFlatTree& c,
     EditingBoundaryCrossingRule boundaryCrossingRule) {
   return startOfParagraphAlgorithm<EditingInFlatTreeStrategy>(
       c, boundaryCrossingRule);
 }
 
 template <typename Strategy>
-VisiblePositionTemplate<Strategy> startOfParagraphAlgorithmDeprecated(
-    const VisiblePositionTemplate<Strategy>& visiblePosition,
-    EditingBoundaryCrossingRule boundaryCrossingRule) {
-  return createVisiblePositionDeprecated(startOfParagraphAlgorithm(
-      visiblePosition.deepEquivalent(), boundaryCrossingRule));
-}
-
-VisiblePosition startOfParagraphDeprecated(
-    const VisiblePosition& c,
-    EditingBoundaryCrossingRule boundaryCrossingRule) {
-  return startOfParagraphAlgorithmDeprecated<EditingStrategy>(
-      c, boundaryCrossingRule);
-}
-
-VisiblePositionInFlatTree startOfParagraphDeprecated(
-    const VisiblePositionInFlatTree& c,
-    EditingBoundaryCrossingRule boundaryCrossingRule) {
-  return startOfParagraphAlgorithmDeprecated<EditingInFlatTreeStrategy>(
-      c, boundaryCrossingRule);
-}
-
-template <typename Strategy>
 static PositionTemplate<Strategy> endOfParagraphAlgorithm(
     const PositionTemplate<Strategy>& position,
     EditingBoundaryCrossingRule boundaryCrossingRule) {
   Node* const startNode = position.anchorNode();
 
   if (!startNode)
     return PositionTemplate<Strategy>();
 
   if (isRenderedAsNonInlineTableImageOrHR(startNode))
     return PositionTemplate<Strategy>::afterNode(startNode);
@@ skipping 89 matching lines @@
   return endOfParagraphAlgorithm<EditingStrategy>(c, boundaryCrossingRule);
 }
 
 VisiblePositionInFlatTree endOfParagraph(
     const VisiblePositionInFlatTree& c,
     EditingBoundaryCrossingRule boundaryCrossingRule) {
   return endOfParagraphAlgorithm<EditingInFlatTreeStrategy>(
       c, boundaryCrossingRule);
 }
 
-template <typename Strategy>
-static VisiblePositionTemplate<Strategy> endOfParagraphAlgorithmDeprecated(
-    const VisiblePositionTemplate<Strategy>& visiblePosition,
-    EditingBoundaryCrossingRule boundaryCrossingRule) {
-  return createVisiblePositionDeprecated(endOfParagraphAlgorithm(
-      visiblePosition.deepEquivalent(), boundaryCrossingRule));
-}
-
-VisiblePosition endOfParagraphDeprecated(
-    const VisiblePosition& c,
-    EditingBoundaryCrossingRule boundaryCrossingRule) {
-  return endOfParagraphAlgorithmDeprecated<EditingStrategy>(
-      c, boundaryCrossingRule);
-}
-
-VisiblePositionInFlatTree endOfParagraphDeprecated(
-    const VisiblePositionInFlatTree& c,
-    EditingBoundaryCrossingRule boundaryCrossingRule) {
-  return endOfParagraphAlgorithmDeprecated<EditingInFlatTreeStrategy>(
-      c, boundaryCrossingRule);
-}
-
 // FIXME: isStartOfParagraph(startOfNextParagraph(pos)) is not always true
 VisiblePosition startOfNextParagraph(const VisiblePosition& visiblePosition) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   VisiblePosition paragraphEnd(
       endOfParagraph(visiblePosition, CanSkipOverEditingBoundary));
   VisiblePosition afterParagraphEnd(
       nextPositionOf(paragraphEnd, CannotCrossEditingBoundary));
   // The position after the last position in the last cell of a table
   // is not the start of the next paragraph.
   if (tableElementJustBefore(afterParagraphEnd))
     return nextPositionOf(afterParagraphEnd, CannotCrossEditingBoundary);
   return afterParagraphEnd;
 }
 
 // FIXME: isStartOfParagraph(startOfNextParagraph(pos)) is not always true
-VisiblePosition startOfNextParagraphDeprecated(
-    const VisiblePosition& visiblePosition) {
-  VisiblePosition paragraphEnd(
-      endOfParagraphDeprecated(visiblePosition, CanSkipOverEditingBoundary));
-  VisiblePosition afterParagraphEnd(
-      nextPositionOf(paragraphEnd, CannotCrossEditingBoundary));
-  // The position after the last position in the last cell of a table
-  // is not the start of the next paragraph.
-  if (tableElementJustBefore(afterParagraphEnd))
-    return nextPositionOf(afterParagraphEnd, CannotCrossEditingBoundary);
-  return afterParagraphEnd;
-}
-
 bool inSameParagraph(const VisiblePosition& a,
                      const VisiblePosition& b,
                      EditingBoundaryCrossingRule boundaryCrossingRule) {
   DCHECK(a.isValid()) << a;
   DCHECK(b.isValid()) << b;
   return a.isNotNull() &&
          startOfParagraph(a, boundaryCrossingRule).deepEquivalent() ==
              startOfParagraph(b, boundaryCrossingRule).deepEquivalent();
 }
 
-bool inSameParagraphDeprecated(
-    const VisiblePosition& a,
-    const VisiblePosition& b,
-    EditingBoundaryCrossingRule boundaryCrossingRule) {
-  return a.isNotNull() &&
-         startOfParagraphDeprecated(a, boundaryCrossingRule).deepEquivalent() ==
-             startOfParagraphDeprecated(b, boundaryCrossingRule)
-                 .deepEquivalent();
-}
-
 template <typename Strategy>
 static bool isStartOfParagraphAlgorithm(
     const VisiblePositionTemplate<Strategy>& pos,
     EditingBoundaryCrossingRule boundaryCrossingRule) {
   DCHECK(pos.isValid()) << pos;
   return pos.isNotNull() &&
          pos.deepEquivalent() ==
              startOfParagraph(pos, boundaryCrossingRule).deepEquivalent();
 }
 
 bool isStartOfParagraph(const VisiblePosition& pos,
                         EditingBoundaryCrossingRule boundaryCrossingRule) {
   return isStartOfParagraphAlgorithm<EditingStrategy>(pos,
                                                       boundaryCrossingRule);
 }
 
 bool isStartOfParagraph(const VisiblePositionInFlatTree& pos,
                         EditingBoundaryCrossingRule boundaryCrossingRule) {
   return isStartOfParagraphAlgorithm<EditingInFlatTreeStrategy>(
       pos, boundaryCrossingRule);
 }
 
 template <typename Strategy>
-static bool isStartOfParagraphAlgorithmDeprecated(
-    const VisiblePositionTemplate<Strategy>& pos,
-    EditingBoundaryCrossingRule boundaryCrossingRule) {
-  return pos.isNotNull() &&
-         pos.deepEquivalent() ==
-             startOfParagraphDeprecated(pos, boundaryCrossingRule)
-                 .deepEquivalent();
-}
-
-bool isStartOfParagraphDeprecated(
-    const VisiblePosition& pos,
-    EditingBoundaryCrossingRule boundaryCrossingRule) {
-  return isStartOfParagraphAlgorithmDeprecated<EditingStrategy>(
-      pos, boundaryCrossingRule);
-}
-
-bool isStartOfParagraphDeprecated(
-    const VisiblePositionInFlatTree& pos,
-    EditingBoundaryCrossingRule boundaryCrossingRule) {
-  return isStartOfParagraphAlgorithmDeprecated<EditingInFlatTreeStrategy>(
-      pos, boundaryCrossingRule);
-}
-
-template <typename Strategy>
 static bool isEndOfParagraphAlgorithm(
     const VisiblePositionTemplate<Strategy>& pos,
     EditingBoundaryCrossingRule boundaryCrossingRule) {
   DCHECK(pos.isValid()) << pos;
   return pos.isNotNull() &&
          pos.deepEquivalent() ==
              endOfParagraph(pos, boundaryCrossingRule).deepEquivalent();
 }
 
 bool isEndOfParagraph(const VisiblePosition& pos,
                       EditingBoundaryCrossingRule boundaryCrossingRule) {
   return isEndOfParagraphAlgorithm<EditingStrategy>(pos, boundaryCrossingRule);
 }
 
 bool isEndOfParagraph(const VisiblePositionInFlatTree& pos,
                       EditingBoundaryCrossingRule boundaryCrossingRule) {
   return isEndOfParagraphAlgorithm<EditingInFlatTreeStrategy>(
       pos, boundaryCrossingRule);
 }
 
-template <typename Strategy>
-static bool isEndOfParagraphAlgorithmDeprecated(
-    const VisiblePositionTemplate<Strategy>& pos,
-    EditingBoundaryCrossingRule boundaryCrossingRule) {
-  return pos.isNotNull() &&
-         pos.deepEquivalent() ==
-             endOfParagraphDeprecated(pos, boundaryCrossingRule)
-                 .deepEquivalent();
-}
-
-bool isEndOfParagraphDeprecated(
-    const VisiblePosition& pos,
-    EditingBoundaryCrossingRule boundaryCrossingRule) {
-  return isEndOfParagraphAlgorithmDeprecated<EditingStrategy>(
-      pos, boundaryCrossingRule);
-}
-
-bool isEndOfParagraphDeprecated(
-    const VisiblePositionInFlatTree& pos,
-    EditingBoundaryCrossingRule boundaryCrossingRule) {
-  return isEndOfParagraphAlgorithmDeprecated<EditingInFlatTreeStrategy>(
-      pos, boundaryCrossingRule);
-}
-
 VisiblePosition previousParagraphPosition(const VisiblePosition& p,
                                           LayoutUnit x) {
   DCHECK(p.isValid()) << p;
   VisiblePosition pos = p;
   do {
     VisiblePosition n = previousLinePosition(pos, x);
     if (n.isNull() || n.deepEquivalent() == pos.deepEquivalent())
       break;
     pos = n;
   } while (inSameParagraph(p, pos));
@@ skipping 1715 matching lines @@
 }
 
 VisiblePositionInFlatTree nextPositionOf(
     const VisiblePositionInFlatTree& visiblePosition,
     EditingBoundaryCrossingRule rule) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   return nextPositionOfAlgorithm<EditingInFlatTreeStrategy>(
       visiblePosition.toPositionWithAffinity(), rule);
 }
 
-VisiblePosition nextPositionOfDeprecated(const VisiblePosition& visiblePosition,
-                                         EditingBoundaryCrossingRule rule) {
-  if (visiblePosition.isNull())
-    return VisiblePosition();
-  visiblePosition.deepEquivalent()
-      .document()
-      ->updateStyleAndLayoutIgnorePendingStylesheets();
-  return nextPositionOfAlgorithm<EditingStrategy>(
-      visiblePosition.toPositionWithAffinity(), rule);
-}
-
-VisiblePositionInFlatTree nextPositionOfDeprecated(
-    const VisiblePositionInFlatTree& visiblePosition,
-    EditingBoundaryCrossingRule rule) {
-  if (visiblePosition.isNull())
-    return VisiblePositionInFlatTree();
-  visiblePosition.deepEquivalent()
-      .document()
-      ->updateStyleAndLayoutIgnorePendingStylesheets();
-  return nextPositionOfAlgorithm<EditingInFlatTreeStrategy>(
-      visiblePosition.toPositionWithAffinity(), rule);
-}
-
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> skipToStartOfEditingBoundary(
     const VisiblePositionTemplate<Strategy>& pos,
     const PositionTemplate<Strategy>& anchor) {
   DCHECK(pos.isValid()) << pos;
   if (pos.isNull())
     return pos;
 
   ContainerNode* highestRoot = highestEditableRoot(anchor);
   ContainerNode* highestRootOfPos = highestEditableRoot(pos.deepEquivalent());
@@ skipping 58 matching lines @@
 }
 
 VisiblePositionInFlatTree previousPositionOf(
     const VisiblePositionInFlatTree& visiblePosition,
     EditingBoundaryCrossingRule rule) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(
       visiblePosition.deepEquivalent(), rule);
 }
 
-VisiblePosition previousPositionOfDeprecated(
-    const VisiblePosition& visiblePosition,
-    EditingBoundaryCrossingRule rule) {
-  if (visiblePosition.isNull())
-    return VisiblePosition();
-  visiblePosition.deepEquivalent()
-      .document()
-      ->updateStyleAndLayoutIgnorePendingStylesheets();
-  return previousPositionOfAlgorithm<EditingStrategy>(
-      visiblePosition.deepEquivalent(), rule);
-}
-
-VisiblePositionInFlatTree previousPositionOfDeprecated(
-    const VisiblePositionInFlatTree& visiblePosition,
-    EditingBoundaryCrossingRule rule) {
-  if (visiblePosition.isNull())
-    return VisiblePositionInFlatTree();
-  visiblePosition.deepEquivalent()
-      .document()
-      ->updateStyleAndLayoutIgnorePendingStylesheets();
-  return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(
-      visiblePosition.deepEquivalent(), rule);
-}
-
 }  // namespace blink