Have Node::document() return a reference instead of a pointer

Source/core/dom/SelectorQuery.cpp

 /*
  * Copyright (C) 2011 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 130 matching lines @@
 
 inline bool SelectorDataList::selectorMatches(const SelectorData& selectorData, Element* element, const Node* rootNode) const
 {
     if (selectorData.isFastCheckable && !element->isSVGElement()) {
         SelectorCheckerFastPath selectorCheckerFastPath(selectorData.selector, element);
         if (!selectorCheckerFastPath.matchesRightmostSelector(SelectorChecker::VisitedMatchDisabled))
             return false;
         return selectorCheckerFastPath.matches();
     }
 
-    SelectorChecker selectorChecker(element->document(), SelectorChecker::QueryingRules);
+    SelectorChecker selectorChecker(&element->document(), SelectorChecker::QueryingRules);
     SelectorChecker::SelectorCheckingContext selectorCheckingContext(selectorData.selector, element, SelectorChecker::VisitedMatchDisabled);
     selectorCheckingContext.behaviorAtBoundary = SelectorChecker::StaysWithinTreeScope;
     selectorCheckingContext.scope = !rootNode->isDocumentNode() && rootNode->isContainerNode() ? toContainerNode(rootNode) : 0;
     PseudoId ignoreDynamicPseudo = NOPSEUDO;
     return selectorChecker.match(selectorCheckingContext, ignoreDynamicPseudo, DOMSiblingTraversalStrategy()) == SelectorChecker::SelectorMatches;
 }
 
 bool SelectorDataList::matches(Element* targetElement) const
 {
     ASSERT(targetElement);
@@ skipping 54 matching lines @@
 {
     for (Element* element = ElementTraversal::firstWithin(rootNode); element; element = ElementTraversal::next(element, rootNode)) {
         if (SelectorChecker::tagMatches(element, tagName))
             return element;
     }
     return 0;
 }
 
 inline bool SelectorDataList::canUseFastQuery(Node* rootNode) const
 {
-    return m_selectors.size() == 1 && rootNode->inDocument() && !rootNode->document()->inQuirksMode();
+    return m_selectors.size() == 1 && rootNode->inDocument() && !rootNode->document().inQuirksMode();
 }
 
 // If returns true, traversalRoots has the elements that may match the selector query.
 //
 // If returns false, traversalRoots has the rootNode parameter or descendants of rootNode representing
 // the subtree for which we can limit the querySelector traversal.
 //
 // The travseralRoots may be empty, regardless of the returned bool value, if this method finds that the selectors won't
 // match any element.
 PassOwnPtr<SimpleNodeList> SelectorDataList::findTraverseRoots(Node* rootNode, bool& matchTraverseRoots) const
 {
     // We need to return the matches in document order. To use id lookup while there is possiblity of multiple matches
     // we would need to sort the results. For now, just traverse the document in that case.
     ASSERT(rootNode);
     ASSERT(m_selectors.size() == 1);
     ASSERT(m_selectors[0].selector);
 
     bool isRightmostSelector = true;
     bool startFromParent = false;
 
     for (const CSSSelector* selector = m_selectors[0].selector; selector; selector = selector->tagHistory()) {
-        if (selector->m_match == CSSSelector::Id && !rootNode->document()->containsMultipleElementsWithId(selector->value())) {
+        if (selector->m_match == CSSSelector::Id && !rootNode->document().containsMultipleElementsWithId(selector->value())) {
             Element* element = rootNode->treeScope()->getElementById(selector->value());
             if (element && (isTreeScopeRoot(rootNode) || element->isDescendantOf(rootNode)))
                 rootNode = element;
             else if (!element || isRightmostSelector)
                 rootNode = 0;
             if (isRightmostSelector) {
                 matchTraverseRoots = true;
                 return adoptPtr(new SingleNodeList(rootNode));
             }
             if (startFromParent && rootNode)
@@ skipping 47 matching lines @@
     ASSERT(m_selectors.size() == 1);
     ASSERT(m_selectors[0].selector);
 
     const CSSSelector* firstSelector = m_selectors[0].selector;
 
     if (!firstSelector->tagHistory()) {
         // Fast path for querySelectorAll('#id'), querySelectorAl('.foo'), and querySelectorAll('div').
         switch (firstSelector->m_match) {
         case CSSSelector::Id:
             {
-                if (rootNode->document()->containsMultipleElementsWithId(firstSelector->value()))
+                if (rootNode->document().containsMultipleElementsWithId(firstSelector->value()))
                     break;
 
                 // Just the same as getElementById.
                 Element* element = rootNode->treeScope()->getElementById(firstSelector->value());
                 if (element && (isTreeScopeRoot(rootNode) || element->isDescendantOf(rootNode)))
                     matchedElements.append(element);
                 return;
             }
         case CSSSelector::Class:
             return collectElementsByClassName(rootNode, firstSelector->value(), matchedElements);
@@ skipping 40 matching lines @@
 {
     // We need to return the matches in document order. To use id lookup while there is possiblity of multiple matches
     // we would need to sort the results. For now, just traverse the document in that case.
     ASSERT(rootNode);
     ASSERT(m_selectors.size() == 1);
     ASSERT(m_selectors[0].selector);
 
     bool matchSingleNode = true;
     bool startFromParent = false;
     for (const CSSSelector* selector = m_selectors[0].selector; selector; selector = selector->tagHistory()) {
-        if (selector->m_match == CSSSelector::Id && !rootNode->document()->containsMultipleElementsWithId(selector->value())) {
+        if (selector->m_match == CSSSelector::Id && !rootNode->document().containsMultipleElementsWithId(selector->value())) {
             Element* element = rootNode->treeScope()->getElementById(selector->value());
             if (element && (isTreeScopeRoot(rootNode) || element->isDescendantOf(rootNode)))
                 rootNode = element;
             else if (!element || matchSingleNode)
                 rootNode = 0;
             if (matchSingleNode) {
                 matchTraverseRoot = true;
                 return rootNode;
             }
             if (startFromParent && rootNode)
@@ skipping 32 matching lines @@
 
     const CSSSelector* selector = m_selectors[0].selector;
     ASSERT(selector);
 
     if (!selector->tagHistory()) {
         // Fast path for querySelector('#id'), querySelector('.foo'), and querySelector('div').
         // Many web developers uses querySelector with these simple selectors.
         switch (selector->m_match) {
         case CSSSelector::Id:
             {
-                if (rootNode->document()->containsMultipleElementsWithId(selector->value()))
+                if (rootNode->document().containsMultipleElementsWithId(selector->value()))
                     break;
                 Element* element = rootNode->treeScope()->getElementById(selector->value());
                 return element && (isTreeScopeRoot(rootNode) || element->isDescendantOf(rootNode)) ? element : 0;
             }
         case CSSSelector::Class:
             return findElementByClassName(rootNode, selector->value());
         case CSSSelector::Tag:
             return findElementByTagName(rootNode, selector->tagQName());
         default:
             break; // If we need another fast path, add here.
@@ skipping 69 matching lines @@
     m_entries.add(selectors, selectorQuery.release());
     return rawSelectorQuery;
 }
 
 void SelectorQueryCache::invalidate()
 {
     m_entries.clear();
 }
 
 }