Use stricter typing for NodeLists throughout the code base

Source/core/dom/ParentNode.h

 /*
  * Copyright (C) 2013 Samsung Electronics. 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.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef ParentNode_h
 #define ParentNode_h
 
+#include "core/dom/ClassCollection.h"
 #include "core/dom/ContainerNode.h"
 #include "core/dom/ElementTraversal.h"
+#include "core/dom/NameNodeList.h"
+#include "core/dom/TagCollection.h"

[adamk, 2014/06/16 20:23:17]

Why are these additional #includes needed? I understand that ParentNode.h isn't
included many places, but adding more includes to a header unnecessarily is
generally likely to slow down compilation.

[Inactive, 2014/06/16 20:35:50]

This is needed so that the generated V8Document.cpp compiles. The generated
V8Document.cpp currently includes V8NodeList.h which is no longer sufficient.
One common workaround for this is to include the necessary includes to the
implementation header (here Document.h). However, I cannot include these in
Document.h at this pointer because they include "Document.h" themselves and I
get a circular dependency. One solution I have found, for now, is to include
those here as V8Document.cpp include this header (Document implements
ParentNode). Ideally, we would have a way to tell the bindings generator to
include specific headers, e.g.:
[IncludeAs=TagCollection] HTMLCollection getElementsByTagName(DOMString
localName);

Another workaround would be to duplicate the methods on native side:
class TagCollection; // Forward declaration is enough.
TagCollection* getElementsByTagName(const String&);
HTMLCollection* getElementsByTagNameForBindings(const String&); // The one for
bindings needs to return the IDL type.

 #include "platform/heap/Handle.h"
 
 namespace WebCore {
 
 class ParentNode {
 public:
     static PassRefPtrWillBeRawPtr<HTMLCollection> children(ContainerNode& node)
     {
         return node.children();
     }
@@ skipping 14 matching lines @@
         for (Element* child = ElementTraversal::firstWithin(node); child; child = ElementTraversal::nextSibling(*child))
             ++count;
         return count;
     }
 
     static PassRefPtrWillBeRawPtr<Element> querySelector(ContainerNode& node, const AtomicString& selectors, ExceptionState& exceptionState)
     {
         return node.querySelector(selectors, exceptionState);
     }
 
-    static PassRefPtrWillBeRawPtr<NodeList> querySelectorAll(ContainerNode& node, const AtomicString& selectors, ExceptionState& exceptionState)
+    static PassRefPtrWillBeRawPtr<StaticNodeList> querySelectorAll(ContainerNode& node, const AtomicString& selectors, ExceptionState& exceptionState)
     {
         return node.querySelectorAll(selectors, exceptionState);
     }
 };
 
 } // namespace WebCore
 
 #endif // ParentNode_h