Return reference from styleEngine() accessor.

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 389 matching lines @@
     documentStyleSheetCollection()->clearMediaQueryRuleSetStyleSheets();
     clearMediaQueryRuleSetOnTreeScopeStyleSheets(m_activeTreeScopes.beginUnordered(), m_activeTreeScopes.endUnordered());
     clearMediaQueryRuleSetOnTreeScopeStyleSheets(m_dirtyTreeScopes.begin(), m_dirtyTreeScopes.end());
 }
 
 void StyleEngine::updateStyleSheetsInImport(DocumentStyleSheetCollector& parentCollector)
 {
     ASSERT(!isMaster());
     WillBeHeapVector<RefPtrWillBeMember<StyleSheet> > sheetsForList;
     ImportedDocumentStyleSheetCollector subcollector(parentCollector, sheetsForList);
-    documentStyleSheetCollection()->collectStyleSheets(this, subcollector);
+    documentStyleSheetCollection()->collectStyleSheets(*this, subcollector);
     documentStyleSheetCollection()->swapSheetsForSheetList(sheetsForList);
 }
 
 void StyleEngine::updateActiveStyleSheetsInShadow(StyleResolverUpdateMode updateMode, TreeScope* treeScope, UnorderedTreeScopeSet& treeScopesRemoved)
 {
     ASSERT(treeScope != m_document);
     ShadowTreeStyleSheetCollection* collection = static_cast<ShadowTreeStyleSheetCollection*>(styleSheetCollectionFor(*treeScope));
     ASSERT(collection);
-    collection->updateActiveStyleSheets(this, updateMode);
+    collection->updateActiveStyleSheets(*this, updateMode);
     if (!collection->hasStyleSheetCandidateNodes()) {
         treeScopesRemoved.add(treeScope);
         // When removing TreeScope from ActiveTreeScopes,
         // its resolver should be destroyed by invoking resetAuthorStyle.
         ASSERT(!treeScope->scopedStyleResolver());
     }
 }
 
 void StyleEngine::updateActiveStyleSheets(StyleResolverUpdateMode updateMode)
 {
     ASSERT(isMaster());
     ASSERT(!document().inStyleRecalc());
 
     if (!document().isActive())
         return;
 
     if (shouldUpdateDocumentStyleSheetCollection(updateMode))
-        documentStyleSheetCollection()->updateActiveStyleSheets(this, updateMode);
+        documentStyleSheetCollection()->updateActiveStyleSheets(*this, updateMode);
 
     if (shouldUpdateShadowTreeStyleSheetCollection(updateMode)) {
         UnorderedTreeScopeSet treeScopesRemoved;
 
         if (updateMode == FullStyleUpdate) {
             for (unsigned i = 0; i < m_activeTreeScopes.size(); ++i)
                 updateActiveStyleSheetsInShadow(updateMode, m_activeTreeScopes[i], treeScopesRemoved);
         } else {
             for (UnorderedTreeScopeSet::iterator it = m_dirtyTreeScopes.begin(); it != m_dirtyTreeScopes.end(); ++it) {
                 updateActiveStyleSheetsInShadow(updateMode, *it, treeScopesRemoved);
@@ skipping 90 matching lines @@
         (*it)->clearScopedStyleResolver();
 
     if (m_resolver)
         document().updateStyleInvalidationIfNeeded();
     m_resolver.clear();
 }
 
 void StyleEngine::clearMasterResolver()
 {
     if (Document* master = this->master())
-        master->styleEngine()->clearResolver();
+        master->styleEngine().clearResolver();
 }
 
 unsigned StyleEngine::resolverAccessCount() const
 {
     return m_resolver ? m_resolver->accessCount() : 0;
 }
 
 void StyleEngine::didDetach()
 {
     clearResolver();
@@ skipping 64 matching lines @@
         return;
     }
 
     m_dirtyTreeScopes.add(&scope);
 }
 
 void StyleEngine::markDocumentDirty()
 {
     m_documentScopeDirty = true;
     if (document().importLoader())
-        document().importsController()->master()->styleEngine()->markDocumentDirty();
+        document().importsController()->master()->styleEngine().markDocumentDirty();
 }
 
 static bool isCacheableForStyleElement(const StyleSheetContents& contents)
 {
     // FIXME: Support copying import rules.
     if (!contents.importRules().isEmpty())
         return false;
     // Until import rules are supported in cached sheets it's not possible for loading to fail.
     ASSERT(!contents.didLoadErrorOccur());
     // It is not the original sheet anymore.
     if (contents.isMutable())
         return false;
     if (!contents.hasSyntacticallyValidCSSHeader())
         return false;
     return true;
 }
 
 PassRefPtrWillBeRawPtr<CSSStyleSheet> StyleEngine::createSheet(Element* e, const String& text, TextPosition startPosition, bool createdByParser)
 {
     RefPtrWillBeRawPtr<CSSStyleSheet> styleSheet = nullptr;
 
-    e->document().styleEngine()->addPendingSheet();
+    e->document().styleEngine().addPendingSheet();
 
     if (!e->document().inQuirksMode()) {
         AtomicString textContent(text);
 
         WillBeHeapHashMap<AtomicString, RawPtrWillBeMember<StyleSheetContents> >::AddResult result = m_textToSheetCache.add(textContent, nullptr);
         if (result.isNewEntry || !result.storedValue->value) {
             styleSheet = StyleEngine::parseSheet(e, text, startPosition, createdByParser);
             if (result.isNewEntry && isCacheableForStyleElement(*styleSheet->contents())) {
                 result.storedValue->value = styleSheet->contents();
                 m_sheetToTextCache.add(styleSheet->contents(), textContent);
@@ skipping 84 matching lines @@
     visitor->trace(m_dirtyTreeScopes);
     visitor->trace(m_activeTreeScopes);
     visitor->trace(m_fontSelector);
     visitor->trace(m_textToSheetCache);
     visitor->trace(m_sheetToTextCache);
 #endif
     CSSFontSelectorClient::trace(visitor);
 }
 
 }