Split TraversalRange out of node_traversal.h

This is in preparation for https://chromium-review.googlesource.com/c/chromium/src/+/1205924,
so we don't need to do forward declarataion for template definitions in NodeTraversal and
any other traversals.

Bug: 880052
Change-Id: Ie2decfb0763f4dfe3f85cace21601c893f263563
Reviewed-on: https://chromium-review.googlesource.com/1212374Reviewed-by: Kent Tamura <tkent@chromium.org>
Commit-Queue: Hayato Ito <hayato@chromium.org>
Cr-Commit-Position: refs/heads/master@{#589484}

third_party/blink/renderer/core/dom/BUILD.gn

@@ -256,6 +256,7 @@ blink_core_sources("dom") {
     "throw_on_dynamic_markup_insertion_count_incrementer.h",
     "transform_source.h",
     "transform_source_libxslt.cc",
+    "traversal_range.h",
     "tree_ordered_list.cc",
     "tree_ordered_list.h",
     "tree_ordered_map.cc",

third_party/blink/renderer/core/dom/element_traversal.h

@@ -30,6 +30,7 @@
 
 #include "third_party/blink/renderer/core/dom/element.h"
 #include "third_party/blink/renderer/core/dom/node_traversal.h"
+#include "third_party/blink/renderer/core/dom/traversal_range.h"
 #include "third_party/blink/renderer/platform/wtf/allocator.h"
 
 namespace blink {

third_party/blink/renderer/core/dom/flat_tree_traversal.h

@@ -32,6 +32,7 @@
 #include "third_party/blink/renderer/core/dom/layout_tree_builder_traversal.h"
 #include "third_party/blink/renderer/core/dom/node_traversal.h"
 #include "third_party/blink/renderer/core/dom/shadow_root.h"
+#include "third_party/blink/renderer/core/dom/traversal_range.h"
 #include "third_party/blink/renderer/core/dom/v0_insertion_point.h"
 #include "third_party/blink/renderer/platform/wtf/allocator.h"
 

third_party/blink/renderer/core/dom/node_traversal.h

@@ -31,23 +31,11 @@
 #include "third_party/blink/renderer/core/core_export.h"
 #include "third_party/blink/renderer/core/dom/container_node.h"
 #include "third_party/blink/renderer/core/dom/node.h"
+#include "third_party/blink/renderer/core/dom/traversal_range.h"
 #include "third_party/blink/renderer/platform/wtf/allocator.h"
 
 namespace blink {
 
-template <class Iterator>
-class TraversalRange;
-template <class TraversalNext>
-class TraversalAncestorsIterator;
-template <class TraversalNext>
-class TraversalChildrenIterator;
-template <class TraversalNext>
-class TraversalDescendantIterator;
-template <class TraversalNext>
-class TraversalInclusiveDescendantIterator;
-template <class TraversalNext>
-class TraversalNextIterator;
-
 class NodeTraversal {
   STATIC_ONLY(NodeTraversal);
 
@@ -167,133 +155,6 @@ class NodeTraversal {
                                                 const Node* stay_within);
 };
 
-template <class Iterator>
-class TraversalRange {
-  STACK_ALLOCATED();
-
- public:
-  using StartNodeType = typename Iterator::StartNodeType;
-  explicit TraversalRange(const StartNodeType* start) : start_(start) {}
-  Iterator begin() { return Iterator(start_); }
-  Iterator end() { return Iterator::End(); }
-
- private:
-  Member<const StartNodeType> start_;
-};
-
-// TODO(yoichio): Simplify iterator templates.
-template <class TraversalNext>
-class TraversalIteratorBase {
-  STACK_ALLOCATED();
-
- public:
-  using NodeType = typename TraversalNext::TraversalNodeType;
-  NodeType& operator*() { return *current_; }
-  bool operator!=(const TraversalIteratorBase& rval) const {
-    return current_ != rval.current_;
-  }
-
- protected:
-  explicit TraversalIteratorBase(NodeType* current) : current_(current) {}
-
-  Member<NodeType> current_;
-};
-
-template <class TraversalNext>
-class TraversalAncestorsIterator : public TraversalIteratorBase<TraversalNext> {
-  STACK_ALLOCATED();
-
- public:
-  using StartNodeType = Node;
-  using TraversalIteratorBase<TraversalNext>::current_;
-  explicit TraversalAncestorsIterator(const StartNodeType* start)
-      : TraversalIteratorBase<TraversalNext>(
-            const_cast<StartNodeType*>(start)) {}
-  void operator++() { current_ = TraversalNext::Parent(*current_); }
-  static TraversalAncestorsIterator End() {
-    return TraversalAncestorsIterator();
-  }
-
- private:
-  TraversalAncestorsIterator()
-      : TraversalIteratorBase<TraversalNext>(nullptr) {}
-};
-
-template <class TraversalNext>
-class TraversalChildrenIterator : public TraversalIteratorBase<TraversalNext> {
-  STACK_ALLOCATED();
-
- public:
-  using StartNodeType = Node;
-  using TraversalIteratorBase<TraversalNext>::current_;
-  explicit TraversalChildrenIterator(const StartNodeType* start)
-      : TraversalIteratorBase<TraversalNext>(
-            TraversalNext::FirstChild(*start)) {}
-  void operator++() { current_ = TraversalNext::NextSibling(*current_); }
-  static TraversalChildrenIterator End() { return TraversalChildrenIterator(); }
-
- private:
-  TraversalChildrenIterator() : TraversalIteratorBase<TraversalNext>(nullptr) {}
-};
-
-template <class TraversalNext>
-class TraversalNextIterator : public TraversalIteratorBase<TraversalNext> {
-  STACK_ALLOCATED();
-
- public:
-  using StartNodeType = typename TraversalNext::TraversalNodeType;
-  using TraversalIteratorBase<TraversalNext>::current_;
-  explicit TraversalNextIterator(const StartNodeType* start)
-      : TraversalIteratorBase<TraversalNext>(
-            const_cast<StartNodeType*>(start)) {}
-  void operator++() { current_ = TraversalNext::Next(*current_); }
-  static TraversalNextIterator End() { return TraversalNextIterator(nullptr); }
-};
-
-template <class TraversalNext>
-class TraversalDescendantIterator
-    : public TraversalIteratorBase<TraversalNext> {
-  STACK_ALLOCATED();
-
- public:
-  using StartNodeType = Node;
-  using TraversalIteratorBase<TraversalNext>::current_;
-  explicit TraversalDescendantIterator(const StartNodeType* start)
-      : TraversalIteratorBase<TraversalNext>(
-            TraversalNext::FirstWithin(*start)),
-        root_(start) {}
-  void operator++() { current_ = TraversalNext::Next(*current_, root_); }
-  static TraversalDescendantIterator End() {
-    return TraversalDescendantIterator();
-  }
-
- private:
-  TraversalDescendantIterator()
-      : TraversalIteratorBase<TraversalNext>(nullptr), root_(nullptr) {}
-  Member<const Node> root_;
-};
-
-template <class TraversalNext>
-class TraversalInclusiveDescendantIterator
-    : public TraversalIteratorBase<TraversalNext> {
-  STACK_ALLOCATED();
-
- public:
-  using StartNodeType = typename TraversalNext::TraversalNodeType;
-  using NodeType = typename TraversalNext::TraversalNodeType;
-  using TraversalIteratorBase<TraversalNext>::current_;
-  explicit TraversalInclusiveDescendantIterator(const StartNodeType* start)
-      : TraversalIteratorBase<TraversalNext>(const_cast<NodeType*>(start)),
-        root_(start) {}
-  void operator++() { current_ = TraversalNext::Next(*current_, root_); }
-  static TraversalInclusiveDescendantIterator End() {
-    return TraversalInclusiveDescendantIterator(nullptr);
-  }
-
- private:
-  Member<const StartNodeType> root_;
-};
-
 inline TraversalRange<TraversalAncestorsIterator<NodeTraversal>>
 NodeTraversal::AncestorsOf(const Node& node) {
   return TraversalRange<TraversalAncestorsIterator<NodeTraversal>>(

third_party/blink/renderer/core/dom/traversal_range.h

+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_CORE_DOM_TRAVERSAL_RANGE_H_
+#define THIRD_PARTY_BLINK_RENDERER_CORE_DOM_TRAVERSAL_RANGE_H_
+
+#include "third_party/blink/renderer/platform/heap/handle.h"
+
+namespace blink {
+
+class Node;
+
+template <class Iterator>
+class TraversalRange {
+  STACK_ALLOCATED();
+
+ public:
+  using StartNodeType = typename Iterator::StartNodeType;
+  explicit TraversalRange(const StartNodeType* start) : start_(start) {}
+  Iterator begin() { return Iterator(start_); }
+  Iterator end() { return Iterator::End(); }
+
+ private:
+  Member<const StartNodeType> start_;
+};
+
+// TODO(yoichio): Simplify iterator templates.
+template <class TraversalNext>
+class TraversalIteratorBase {
+  STACK_ALLOCATED();
+
+ public:
+  using NodeType = typename TraversalNext::TraversalNodeType;
+  NodeType& operator*() { return *current_; }
+  bool operator!=(const TraversalIteratorBase& rval) const {
+    return current_ != rval.current_;
+  }
+
+ protected:
+  explicit TraversalIteratorBase(NodeType* current) : current_(current) {}
+
+  Member<NodeType> current_;
+};
+
+template <class TraversalNext>
+class TraversalAncestorsIterator : public TraversalIteratorBase<TraversalNext> {
+  STACK_ALLOCATED();
+
+ public:
+  using StartNodeType = Node;
+  using TraversalIteratorBase<TraversalNext>::current_;
+  explicit TraversalAncestorsIterator(const StartNodeType* start)
+      : TraversalIteratorBase<TraversalNext>(
+            const_cast<StartNodeType*>(start)) {}
+  void operator++() { current_ = TraversalNext::Parent(*current_); }
+  static TraversalAncestorsIterator End() {
+    return TraversalAncestorsIterator();
+  }
+
+ private:
+  TraversalAncestorsIterator()
+      : TraversalIteratorBase<TraversalNext>(nullptr) {}
+};
+
+template <class TraversalNext>
+class TraversalChildrenIterator : public TraversalIteratorBase<TraversalNext> {
+  STACK_ALLOCATED();
+
+ public:
+  using StartNodeType = Node;
+  using TraversalIteratorBase<TraversalNext>::current_;
+  explicit TraversalChildrenIterator(const StartNodeType* start)
+      : TraversalIteratorBase<TraversalNext>(
+            TraversalNext::FirstChild(*start)) {}
+  void operator++() { current_ = TraversalNext::NextSibling(*current_); }
+  static TraversalChildrenIterator End() { return TraversalChildrenIterator(); }
+
+ private:
+  TraversalChildrenIterator() : TraversalIteratorBase<TraversalNext>(nullptr) {}
+};
+
+template <class TraversalNext>
+class TraversalNextIterator : public TraversalIteratorBase<TraversalNext> {
+  STACK_ALLOCATED();
+
+ public:
+  using StartNodeType = typename TraversalNext::TraversalNodeType;
+  using TraversalIteratorBase<TraversalNext>::current_;
+  explicit TraversalNextIterator(const StartNodeType* start)
+      : TraversalIteratorBase<TraversalNext>(
+            const_cast<StartNodeType*>(start)) {}
+  void operator++() { current_ = TraversalNext::Next(*current_); }
+  static TraversalNextIterator End() { return TraversalNextIterator(nullptr); }
+};
+
+template <class TraversalNext>
+class TraversalDescendantIterator
+    : public TraversalIteratorBase<TraversalNext> {
+  STACK_ALLOCATED();
+
+ public:
+  using StartNodeType = Node;
+  using TraversalIteratorBase<TraversalNext>::current_;
+  explicit TraversalDescendantIterator(const StartNodeType* start)
+      : TraversalIteratorBase<TraversalNext>(
+            TraversalNext::FirstWithin(*start)),
+        root_(start) {}
+  void operator++() { current_ = TraversalNext::Next(*current_, root_); }
+  static TraversalDescendantIterator End() {
+    return TraversalDescendantIterator();
+  }
+
+ private:
+  TraversalDescendantIterator()
+      : TraversalIteratorBase<TraversalNext>(nullptr), root_(nullptr) {}
+  Member<const Node> root_;
+};
+
+template <class TraversalNext>
+class TraversalInclusiveDescendantIterator
+    : public TraversalIteratorBase<TraversalNext> {
+  STACK_ALLOCATED();
+
+ public:
+  using StartNodeType = typename TraversalNext::TraversalNodeType;
+  using NodeType = typename TraversalNext::TraversalNodeType;
+  using TraversalIteratorBase<TraversalNext>::current_;
+  explicit TraversalInclusiveDescendantIterator(const StartNodeType* start)
+      : TraversalIteratorBase<TraversalNext>(const_cast<NodeType*>(start)),
+        root_(start) {}
+  void operator++() { current_ = TraversalNext::Next(*current_, root_); }
+  static TraversalInclusiveDescendantIterator End() {
+    return TraversalInclusiveDescendantIterator(nullptr);
+  }
+
+ private:
+  Member<const StartNodeType> root_;
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_CORE_DOM_TRAVERSAL_RANGE_H_