Make stylesheet owner node a reference instead of pointer.

third_party/WebKit/Source/core/dom/StyleEngine.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
@@ skipping 107 matching lines @@
 void StyleEngine::resetCSSFeatureFlags(const RuleFeatureSet& features)
 {
     m_usesSiblingRules = features.usesSiblingRules();
     m_usesFirstLineRules = features.usesFirstLineRules();
     m_usesWindowInactiveSelector = features.usesWindowInactiveSelector();
     m_maxDirectAdjacentSelectors = features.maxDirectAdjacentSelectors();
 }
 
 void StyleEngine::injectAuthorSheet(StyleSheetContents* authorSheet)
 {
-    m_injectedAuthorStyleSheets.append(CSSStyleSheet::create(authorSheet, m_document));
+    m_injectedAuthorStyleSheets.append(CSSStyleSheet::create(authorSheet, *m_document));
     markDocumentDirty();
     resolverChanged(AnalyzedStyleUpdate);
 }
 
 CSSStyleSheet& StyleEngine::ensureInspectorStyleSheet()
 {
     if (m_inspectorStyleSheet)
         return *m_inspectorStyleSheet;
 
     StyleSheetContents* contents = StyleSheetContents::create(CSSParserContext(*m_document, nullptr));
-    m_inspectorStyleSheet = CSSStyleSheet::create(contents, m_document);
+    m_inspectorStyleSheet = CSSStyleSheet::create(contents, *m_document);
     markDocumentDirty();
     resolverChanged(AnalyzedStyleUpdate);
     return *m_inspectorStyleSheet;
 }
 
 void StyleEngine::addPendingSheet(StyleEngineContext &context)
 {
     m_pendingScriptBlockingStylesheets++;
 
     context.addingPendingSheet(document());
     if (context.addedPendingSheetBeforeBody())
         m_pendingRenderBlockingStylesheets++;
 }
 
 // This method is called whenever a top-level stylesheet has finished loading.
-void StyleEngine::removePendingSheet(Node* styleSheetCandidateNode, const StyleEngineContext &context)
+void StyleEngine::removePendingSheet(Node& styleSheetCandidateNode, const StyleEngineContext &context)
 {
-    DCHECK(styleSheetCandidateNode);
-    TreeScope* treeScope = isStyleElement(*styleSheetCandidateNode) ? &styleSheetCandidateNode->treeScope() : m_document.get();
-    if (styleSheetCandidateNode->isConnected())
+    TreeScope* treeScope = isStyleElement(styleSheetCandidateNode) ? &styleSheetCandidateNode.treeScope() : m_document.get();
+    if (styleSheetCandidateNode.isConnected())
         markTreeScopeDirty(*treeScope);
 
     if (context.addedPendingSheetBeforeBody()) {
         DCHECK_GT(m_pendingRenderBlockingStylesheets, 0);
         m_pendingRenderBlockingStylesheets--;
     }
 
     // Make sure we knew this sheet was pending, and that our count isn't out of sync.
     DCHECK_GT(m_pendingScriptBlockingStylesheets, 0);
 
@@ skipping 18 matching lines @@
         if (node && node->isConnected()) {
             TreeScope& treeScope = isStyleElement(*node) ? node->treeScope() : *m_document;
             DCHECK(isStyleElement(*node) || node->treeScope() == m_document);
             markTreeScopeDirty(treeScope);
         }
     }
 
     resolverChanged(updateMode);
 }
 
-void StyleEngine::addStyleSheetCandidateNode(Node* node)
+void StyleEngine::addStyleSheetCandidateNode(Node& node)
 {
-    if (!node->isConnected() || document().isDetached())
+    if (!node.isConnected() || document().isDetached())
         return;
 
-    DCHECK(!isXSLStyleSheet(*node));
-    TreeScope& treeScope = node->treeScope();
+    DCHECK(!isXSLStyleSheet(node));
+    TreeScope& treeScope = node.treeScope();
     TreeScopeStyleSheetCollection* collection = ensureStyleSheetCollectionFor(treeScope);
     DCHECK(collection);
     collection->addStyleSheetCandidateNode(node);
 
     markTreeScopeDirty(treeScope);
     if (treeScope != m_document)
         m_activeTreeScopes.add(&treeScope);
 }
 
-void StyleEngine::removeStyleSheetCandidateNode(Node* node)
+void StyleEngine::removeStyleSheetCandidateNode(Node& node)
 {
     removeStyleSheetCandidateNode(node, *m_document);
 }
 
-void StyleEngine::removeStyleSheetCandidateNode(Node* node, TreeScope& treeScope)
+void StyleEngine::removeStyleSheetCandidateNode(Node& node, TreeScope& treeScope)
 {
-    DCHECK(isStyleElement(*node) || treeScope == m_document);
-    DCHECK(!isXSLStyleSheet(*node));
+    DCHECK(isStyleElement(node) || treeScope == m_document);
+    DCHECK(!isXSLStyleSheet(node));
 
     TreeScopeStyleSheetCollection* collection = styleSheetCollectionFor(treeScope);
     // After detaching document, collection could be null. In the case,
     // we should not update anything. Instead, just return.
     if (!collection)
         return;
     collection->removeStyleSheetCandidateNode(node);
 
     markTreeScopeDirty(treeScope);
 }
 
-void StyleEngine::modifiedStyleSheetCandidateNode(Node* node)
+void StyleEngine::modifiedStyleSheetCandidateNode(Node& node)
 {
-    if (!node->isConnected())
+    if (!node.isConnected())
         return;
 
-    TreeScope& treeScope = isStyleElement(*node) ? node->treeScope() : *m_document;
-    DCHECK(isStyleElement(*node) || treeScope == m_document);
+    TreeScope& treeScope = isStyleElement(node) ? node.treeScope() : *m_document;
+    DCHECK(isStyleElement(node) || treeScope == m_document);
     markTreeScopeDirty(treeScope);
     resolverChanged(AnalyzedStyleUpdate);
 }
 
 void StyleEngine::watchedSelectorsChanged()
 {
     if (m_resolver) {
         m_resolver->initWatchedSelectorRules();
         m_resolver->resetRuleFeatures();
     }
@@ skipping 247 matching lines @@
     m_dirtyTreeScopes.add(&scope);
 }
 
 void StyleEngine::markDocumentDirty()
 {
     m_documentScopeDirty = true;
     if (document().importLoader())
         document().importsController()->master()->styleEngine().markDocumentDirty();
 }
 
-CSSStyleSheet* StyleEngine::createSheet(Element* e, const String& text, TextPosition startPosition, StyleEngineContext &context)
+CSSStyleSheet* StyleEngine::createSheet(Element& element, const String& text, TextPosition startPosition, StyleEngineContext &context)
 {
+    DCHECK(element.document() == document());
     CSSStyleSheet* styleSheet = nullptr;
 
-    e->document().styleEngine().addPendingSheet(context);
+    addPendingSheet(context);
 
     AtomicString textContent(text);
 
     auto result = m_textToSheetCache.add(textContent, nullptr);
     StyleSheetContents* contents = result.storedValue->value;
     if (result.isNewEntry || !contents || !contents->isCacheableForStyleElement()) {
         result.storedValue->value = nullptr;
-        styleSheet = StyleEngine::parseSheet(e, text, startPosition);
+        styleSheet = parseSheet(element, text, startPosition);
         if (styleSheet->contents()->isCacheableForStyleElement()) {
             result.storedValue->value = styleSheet->contents();
             m_sheetToTextCache.add(styleSheet->contents(), textContent);
         }
     } else {
         DCHECK(contents);
         DCHECK(contents->isCacheableForStyleElement());
         DCHECK(contents->hasSingleOwnerDocument());
         contents->setIsUsedFromTextCache();
-        styleSheet = CSSStyleSheet::createInline(contents, e, startPosition);
+        styleSheet = CSSStyleSheet::createInline(contents, element, startPosition);
     }
 
     DCHECK(styleSheet);
-    if (!e->isInShadowTree()) {
-        styleSheet->setTitle(e->title());
-        setPreferredStylesheetSetNameIfNotSet(e->title(), DontUpdateActiveSheets);
+    if (!element.isInShadowTree()) {
+        styleSheet->setTitle(element.title());
+        setPreferredStylesheetSetNameIfNotSet(element.title(), DontUpdateActiveSheets);
     }
     return styleSheet;
 }
 
-CSSStyleSheet* StyleEngine::parseSheet(Element* e, const String& text, TextPosition startPosition)
+CSSStyleSheet* StyleEngine::parseSheet(Element& element, const String& text, TextPosition startPosition)
 {
     CSSStyleSheet* styleSheet = nullptr;
-    styleSheet = CSSStyleSheet::createInline(e, KURL(), startPosition, e->document().characterSet());
+    styleSheet = CSSStyleSheet::createInline(element, KURL(), startPosition, document().characterSet());
     styleSheet->contents()->parseStringAtPosition(text, startPosition);
     return styleSheet;
 }
 
 void StyleEngine::collectScopedStyleFeaturesTo(RuleFeatureSet& features) const
 {
     HeapHashSet<Member<const StyleSheetContents>> visitedSharedStyleSheetContents;
     if (document().scopedStyleResolver())
         document().scopedStyleResolver()->collectFeaturesTo(features, visitedSharedStyleSheetContents);
     for (TreeScope* treeScope : m_activeTreeScopes) {
@@ skipping 281 matching lines @@
 
 DEFINE_TRACE_WRAPPERS(StyleEngine)
 {
     for (auto sheet : m_injectedAuthorStyleSheets) {
         visitor->traceWrappers(sheet);
     }
     visitor->traceWrappers(m_documentStyleSheetCollection);
 }
 
 } // namespace blink