Add Traversal<*Element>::firstAncestor() API

Source/core/dom/ElementTraversal.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2014 Samsung Electronics. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 22 matching lines @@
 
 template <class ElementType>
 class Traversal {
 public:
     // First or last ElementType child of the node.
     static ElementType* firstChild(const ContainerNode& current) { return firstChildTemplate(current); }
     static ElementType* firstChild(const Node& current) { return firstChildTemplate(current); }
     static ElementType* lastChild(const ContainerNode& current) { return lastChildTemplate(current); }
     static ElementType* lastChild(const Node& current) { return lastChildTemplate(current); }
 
+    // First ElementType ancestor of the node.

[esprehn, 2014/03/21 07:58:33]

The comment doesn't add anything.

[Inactive, 2014/03/21 14:37:24]

Each set of ElementTraversal functions is grouped with a comment. If I don't add
a comment, then this new function will be part of an existing group but this one
brings a new functionality.

+    static ElementType* firstAncestor(const Node& current);
+
     // First or last ElementType descendant of the node.
     // For Elements firstWithin() is always the same as firstChild().
     static ElementType* firstWithin(const ContainerNode& current) { return firstWithinTemplate(current); }
     static ElementType* firstWithin(const Node& current) { return firstWithinTemplate(current); }
     static ElementType* lastWithin(const ContainerNode& current) { return lastWithinTemplate(current); }
     static ElementType* lastWithin(const Node& current) { return lastWithinTemplate(current); }
 
     // Pre-order traversal skipping non-element nodes.
     static ElementType* next(const ContainerNode& current) { return nextTemplate(current); }
     static ElementType* next(const Node& current) { return nextTemplate(current); }
@@ skipping 107 matching lines @@
 template <class NodeType>
 inline ElementType* Traversal<ElementType>::firstChildTemplate(NodeType& current)
 {
     Node* node = current.firstChild();
     while (node && !isElementOfType<const ElementType>(*node))
         node = node->nextSibling();
     return toElement<ElementType>(node);
 }
 
 template <class ElementType>
+inline ElementType* Traversal<ElementType>::firstAncestor(const Node& current)
+{
+    ContainerNode* ancestor = current.parentNode();

[Inactive, 2014/03/15 23:50:18]

One idea that came to mind, we could potentially overload firstAncestor() to
take an Element in argument and call parentOrShadowHostNode() instead of
parentNode() to avoid unnecessary calls to isShadowRoot(). (likely we would add
a more optimal Element::parentNode() instead that calls parentOrShadowHostNode()
so that the rest of the code can benefit from this optimization as well).

I need to get measurements to see if there would be any noticeable impact on
performance.

Let me know if you have any thoughts about this.

+    while (ancestor && !isElementOfType<const ElementType>(*ancestor))
+        ancestor = ancestor->parentNode();
+    return toElement<ElementType>(ancestor);
+}
+
+template <class ElementType>
 template <class NodeType>
 inline ElementType* Traversal<ElementType>::lastChildTemplate(NodeType& current)
 {
     Node* node = current.lastChild();
     while (node && !isElementOfType<const ElementType>(*node))
         node = node->previousSibling();
     return toElement<ElementType>(node);
 }
 
 template <class ElementType>
@@ skipping 126 matching lines @@
 {
     Node* node = current.nextSibling();
     while (node && !isElementOfType<const ElementType>(*node))
         node = node->nextSibling();
     return toElement<ElementType>(node);
 }
 
 } // namespace WebCore
 
 #endif