documentStyleSheetCollection() is always non-null.

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.
@@ skipping 74 matching lines @@
   HTMLImportsController* import = document().importsController();
   // Document::import() can return null while executing its destructor.
   if (!import)
     return nullptr;
   return import->master();
 }
 
 TreeScopeStyleSheetCollection* StyleEngine::ensureStyleSheetCollectionFor(
     TreeScope& treeScope) {
   if (treeScope == m_document)
-    return documentStyleSheetCollection();
+    return &documentStyleSheetCollection();
 
   StyleSheetCollectionMap::AddResult result =
       m_styleSheetCollectionMap.add(&treeScope, nullptr);
   if (result.isNewEntry)
     result.storedValue->value =
         new ShadowTreeStyleSheetCollection(toShadowRoot(treeScope));
   return result.storedValue->value.get();
 }
 
 TreeScopeStyleSheetCollection* StyleEngine::styleSheetCollectionFor(
     TreeScope& treeScope) {
   if (treeScope == m_document)
-    return documentStyleSheetCollection();
+    return &documentStyleSheetCollection();
 
   StyleSheetCollectionMap::iterator it =
       m_styleSheetCollectionMap.find(&treeScope);
   if (it == m_styleSheetCollectionMap.end())
-    return 0;
+    return nullptr;
   return it->value.get();
 }
 
 const HeapVector<Member<StyleSheet>>& StyleEngine::styleSheetsForStyleSheetList(
     TreeScope& treeScope) {
   if (treeScope == m_document)
-    return documentStyleSheetCollection()->styleSheetsForStyleSheetList();
+    return documentStyleSheetCollection().styleSheetsForStyleSheetList();
 
   return ensureStyleSheetCollectionFor(treeScope)
       ->styleSheetsForStyleSheetList();
 }
 
 void StyleEngine::resetCSSFeatureFlags(const RuleFeatureSet& features) {
   m_usesSiblingRules = features.usesSiblingRules();
   m_usesFirstLineRules = features.usesFirstLineRules();
   m_usesWindowInactiveSelector = features.usesWindowInactiveSelector();
   m_maxDirectAdjacentSelectors = features.maxDirectAdjacentSelectors();
@@ skipping 146 matching lines @@
     DCHECK(treeScope != m_document);
     ShadowTreeStyleSheetCollection* collection =
         toShadowTreeStyleSheetCollection(styleSheetCollectionFor(*treeScope));
     DCHECK(collection);
     collection->clearMediaQueryRuleSetStyleSheets();
   }
 }
 
 void StyleEngine::clearMediaQueryRuleSetStyleSheets() {
   resolverChanged(FullStyleUpdate);
-  documentStyleSheetCollection()->clearMediaQueryRuleSetStyleSheets();
+  documentStyleSheetCollection().clearMediaQueryRuleSetStyleSheets();
   clearMediaQueryRuleSetOnTreeScopeStyleSheets(m_activeTreeScopes);
 }
 
 void StyleEngine::updateStyleSheetsInImport(
     DocumentStyleSheetCollector& parentCollector) {
   DCHECK(!isMaster());
   HeapVector<Member<StyleSheet>> sheetsForList;
   ImportedDocumentStyleSheetCollector subcollector(parentCollector,
                                                    sheetsForList);
-  documentStyleSheetCollection()->collectStyleSheets(*this, subcollector);
-  documentStyleSheetCollection()->swapSheetsForSheetList(sheetsForList);
+  documentStyleSheetCollection().collectStyleSheets(*this, subcollector);
+  documentStyleSheetCollection().swapSheetsForSheetList(sheetsForList);
 }
 
 void StyleEngine::updateActiveStyleSheetsInShadow(
     StyleResolverUpdateMode updateMode,
     TreeScope* treeScope,
     UnorderedTreeScopeSet& treeScopesRemoved) {
   DCHECK_NE(treeScope, m_document);
   ShadowTreeStyleSheetCollection* collection =
       toShadowTreeStyleSheetCollection(styleSheetCollectionFor(*treeScope));
   DCHECK(collection);
   collection->updateActiveStyleSheets(*this, updateMode);
   if (!collection->hasStyleSheetCandidateNodes()) {
     treeScopesRemoved.add(treeScope);
     // When removing TreeScope from ActiveTreeScopes,
     // its resolver should be destroyed by invoking resetAuthorStyle.
     DCHECK(!treeScope->scopedStyleResolver());
   }
 }
 
 void StyleEngine::updateActiveStyleSheets(StyleResolverUpdateMode updateMode) {
   DCHECK(isMaster());
   DCHECK(!document().inStyleRecalc());
 
   if (!document().isActive())
     return;
 
   TRACE_EVENT0("blink,blink_style", "StyleEngine::updateActiveStyleSheets");
 
   if (shouldUpdateDocumentStyleSheetCollection(updateMode))
-    documentStyleSheetCollection()->updateActiveStyleSheets(*this, updateMode);
+    documentStyleSheetCollection().updateActiveStyleSheets(*this, updateMode);
 
   if (shouldUpdateShadowTreeStyleSheetCollection(updateMode)) {
     UnorderedTreeScopeSet treeScopesRemoved;
 
     if (updateMode == FullStyleUpdate) {
       for (TreeScope* treeScope : m_activeTreeScopes)
         updateActiveStyleSheetsInShadow(updateMode, treeScope,
                                         treeScopesRemoved);
     } else {
       for (TreeScope* treeScope : m_dirtyTreeScopes)
         updateActiveStyleSheetsInShadow(updateMode, treeScope,
                                         treeScopesRemoved);
     }
     for (TreeScope* treeScope : treeScopesRemoved)
       m_activeTreeScopes.remove(treeScope);
   }
 
   InspectorInstrumentation::activeStyleSheetsUpdated(m_document);
 
   m_dirtyTreeScopes.clear();
   m_documentScopeDirty = false;
 }
 
 const HeapVector<Member<CSSStyleSheet>>
 StyleEngine::activeStyleSheetsForInspector() const {
   if (m_activeTreeScopes.isEmpty())
-    return documentStyleSheetCollection()->activeAuthorStyleSheets();
+    return documentStyleSheetCollection().activeAuthorStyleSheets();
 
   HeapVector<Member<CSSStyleSheet>> activeStyleSheets;
 
   activeStyleSheets.appendVector(
-      documentStyleSheetCollection()->activeAuthorStyleSheets());
+      documentStyleSheetCollection().activeAuthorStyleSheets());
   for (TreeScope* treeScope : m_activeTreeScopes) {
     if (TreeScopeStyleSheetCollection* collection =
             m_styleSheetCollectionMap.get(treeScope))
       activeStyleSheets.appendVector(collection->activeAuthorStyleSheets());
   }
 
   // FIXME: Inspector needs a vector which has all active stylesheets.
   // However, creating such a large vector might cause performance regression.
   // Need to implement some smarter solution.
   return activeStyleSheets;
@@ skipping 16 matching lines @@
   }
   m_styleSheetCollectionMap.remove(shadowRoot);
   m_activeTreeScopes.remove(shadowRoot);
   m_dirtyTreeScopes.remove(shadowRoot);
 }
 
 void StyleEngine::appendActiveAuthorStyleSheets() {
   DCHECK(isMaster());
 
   m_resolver->appendAuthorStyleSheets(
-      documentStyleSheetCollection()->activeAuthorStyleSheets());
+      documentStyleSheetCollection().activeAuthorStyleSheets());
   for (TreeScope* treeScope : m_activeTreeScopes) {
     if (TreeScopeStyleSheetCollection* collection =
             m_styleSheetCollectionMap.get(treeScope))
       m_resolver->appendAuthorStyleSheets(
           collection->activeAuthorStyleSheets());
   }
   m_resolver->finishAppendAuthorStyleSheets();
 }
 
 void StyleEngine::createResolver() {
@@ skipping 556 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(StyleEngine) {
   for (auto sheet : m_injectedAuthorStyleSheets) {
     visitor->traceWrappers(sheet);
   }
   visitor->traceWrappers(m_documentStyleSheetCollection);
 }
 
 }  // namespace blink