Refactor LayoutTreeBuilderTraversal to expose a cleaner interface to layout sibling nodes.

third_party/WebKit/Source/core/dom/LayoutTreeBuilderTraversal.h

 /*
  * Copyright (C) 2012 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 19 matching lines @@
 #include "core/CoreExport.h"
 #include "core/dom/Element.h"
 #include "core/dom/shadow/InsertionPoint.h"
 #include <cstdint>
 
 namespace blink {
 
 class LayoutObject;
 
 class CORE_EXPORT LayoutTreeBuilderTraversal {
+  static Node* nextLayoutSibling(const Node&, int32_t& limit);
+  static Node* previousLayoutSibling(const Node&, int32_t& limit);

[rune, 2017/03/10 12:32:41]

I'd put these in a private section below the public section instead. Or since
these are private, couldn't they be static functions in the cpp file instead,
like we do with other methods?

Oh, you're using it below. Will it be a perf-issue if you implement
nextLayoutSibling() in the cpp file instead? I'd guess that the compiler would
inline a static nextLayoutSibling function into that implementation.

+
  public:
   static const int32_t kTraverseAllSiblings = -2;
   class ParentDetails {
     STACK_ALLOCATED();
 
    public:
     ParentDetails() : m_insertionPoint(nullptr) {}
 
     const InsertionPoint* insertionPoint() const { return m_insertionPoint; }
 
     void didTraverseInsertionPoint(const InsertionPoint*);
 
     bool operator==(const ParentDetails& other) {
       return m_insertionPoint == other.m_insertionPoint;
     }
 
    private:
     Member<const InsertionPoint> m_insertionPoint;
   };
 
   static ContainerNode* parent(const Node&, ParentDetails* = nullptr);
   static ContainerNode* layoutParent(const Node&, ParentDetails* = nullptr);
   static Node* firstChild(const Node&);
   static Node* nextSibling(const Node&);
+  static Node* nextLayoutSibling(const Node& node) {
+    int32_t limit = kTraverseAllSiblings;
+    return nextLayoutSibling(node, limit);
+  }
+  static Node* previousLayoutSibling(const Node& node) {
+    int32_t limit = kTraverseAllSiblings;
+    return previousLayoutSibling(node, limit);
+  }
   static Node* previousSibling(const Node&);
   static Node* previous(const Node&, const Node* stayWithin);
   static Node* next(const Node&, const Node* stayWithin);
   static Node* nextSkippingChildren(const Node&, const Node* stayWithin);
   static LayoutObject* parentLayoutObject(const Node&);
   static LayoutObject* nextSiblingLayoutObject(
       const Node&,
       int32_t limit = kTraverseAllSiblings);
   static LayoutObject* previousSiblingLayoutObject(
       const Node&,
       int32_t limit = kTraverseAllSiblings);
   static LayoutObject* nextInTopLayer(const Element&);
 
   static inline Element* parentElement(const Node& node) {
     ContainerNode* found = parent(node);
     return found && found->isElementNode() ? toElement(found) : 0;
   }
 };
 
 }  // namespace blink
 
 #endif