Return reference from styleEngine() accessor.

Source/core/dom/Document.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 551 matching lines @@
 #if !ENABLE(OILPAN)
     if (m_styleSheetList)
         m_styleSheetList->detachFromDocument();
 
     if (m_importsController)
         HTMLImportsController::removeFrom(*this);
 
     m_timeline->detachFromDocument();
 
     // We need to destroy CSSFontSelector before destroying m_fetcher.
-    if (m_styleEngine)
-        m_styleEngine->detachFromDocument();
+    m_styleEngine->detachFromDocument();
 
     if (m_elemSheet)
         m_elemSheet->clearOwnerNode();
 
     // It's possible for multiple Documents to end up referencing the same ResourceFetcher (e.g., SVGImages
     // load the initial empty document and the SVGDocument with the same DocumentLoader).
     FrameFetchContext& context = static_cast<FrameFetchContext&>(m_fetcher->context());
     if (context.document() == this)
         context.setDocument(nullptr);
     m_fetcher.clear();
@@ skipping 76 matching lines @@
 MediaQueryMatcher& Document::mediaQueryMatcher()
 {
     if (!m_mediaQueryMatcher)
         m_mediaQueryMatcher = MediaQueryMatcher::create(*this);
     return *m_mediaQueryMatcher;
 }
 
 void Document::mediaQueryAffectingValueChanged()
 {
     m_evaluateMediaQueriesOnStyleRecalc = true;
-    styleEngine()->clearMediaQueryRuleSetStyleSheets();
+    styleEngine().clearMediaQueryRuleSetStyleSheets();
     InspectorInstrumentation::mediaQueryResultChanged(this);
 }
 
 void Document::setCompatibilityMode(CompatibilityMode mode)
 {
     if (m_compatibilityModeLocked || mode == m_compatibilityMode)
         return;
     bool wasInQuirksMode = inQuirksMode();
     m_compatibilityMode = mode;
     selectorQueryCache().invalidate();
@@ skipping 12 matching lines @@
 {
     // This should never be called more than once.
     ASSERT(!m_docType || !docType);
     m_docType = docType;
     if (m_docType) {
         this->adoptIfNeeded(*m_docType);
         if (m_docType->publicId().startsWith("-//wapforum//dtd xhtml mobile 1.", /* caseSensitive */ false))
             m_isMobileDocument = true;
     }
     // Doctype affects the interpretation of the stylesheets.
-    clearStyleResolver();
+    styleEngine().clearResolver();
 }
 
 DOMImplementation& Document::implementation()
 {
     if (!m_implementation)
         m_implementation = DOMImplementation::create(*this);
     return *m_implementation;
 }
 
 bool Document::hasAppCacheManifest() const
@@ skipping 882 matching lines @@
         return;
     TRACE_EVENT0("blink", "Document::updateStyleInvalidationIfNeeded");
     ASSERT(styleResolver());
 
     styleResolver()->ruleFeatureSet().styleInvalidator().invalidate(*this);
 }
 
 void Document::setupFontBuilder(LayoutStyle& documentStyle)
 {
     FontBuilder fontBuilder(*this);
-    RefPtrWillBeRawPtr<CSSFontSelector> selector = m_styleEngine->fontSelector();
+    RefPtrWillBeRawPtr<CSSFontSelector> selector = styleEngine().fontSelector();
     fontBuilder.createFontForDocument(selector, documentStyle);
 }
 
 void Document::inheritHtmlAndBodyElementStyles(StyleRecalcChange change)
 {
     ASSERT(inStyleRecalc());
     ASSERT(documentElement());
 
     RefPtr<LayoutStyle> documentElementStyle = documentElement()->layoutStyle();
     if (!documentElementStyle || documentElement()->needsStyleRecalc() || change == Force)
@@ skipping 22 matching lines @@
         }
     }
 
     // Resolved rem units are stored in the matched properties cache so we need to make sure to
     // invalidate the cache if the documentElement needed to reattach or the font size changed
     // and then trigger a full document recalc. We also need to clear it here since the
     // call to styleForElement on the body above can cache bad values for rem units if the
     // documentElement's style was dirty. We could keep track of which elements depend on
     // rem units like we do for viewport styles, but we assume root font size changes are
     // rare and just invalidate the cache for now.
-    if (styleEngine()->usesRemUnits() && (documentElement()->needsAttach() || documentElement()->computedStyle()->fontSize() != documentElementStyle->fontSize())) {
+    if (styleEngine().usesRemUnits() && (documentElement()->needsAttach() || documentElement()->computedStyle()->fontSize() != documentElementStyle->fontSize())) {
         ensureStyleResolver().invalidateMatchedPropertiesCache();
         documentElement()->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::FontSizeChange));
     }
 
     EOverflow overflowX = OAUTO;
     EOverflow overflowY = OAUTO;
     float columnGap = 0;
     if (overflowStyle) {
         overflowX = overflowStyle->overflowX();
         overflowY = overflowStyle->overflowY();
@@ skipping 81 matching lines @@
     updateStyleInvalidationIfNeeded();
 
     // FIXME: We should update style on our ancestor chain before proceeding
     // however doing so currently causes several tests to crash, as LocalFrame::setDocument calls Document::attach
     // before setting the LocalDOMWindow on the LocalFrame, or the SecurityOrigin on the document. The attach, in turn
     // resolves style (here) and then when we resolve style on the parent chain, we may end up
     // re-attaching our containing iframe, which when asked HTMLFrameElementBase::isURLAllowed
     // hits a null-dereference due to security code always assuming the document has a SecurityOrigin.
 
     if (m_elemSheet && m_elemSheet->contents()->usesRemUnits())
-        m_styleEngine->setUsesRemUnit(true);
+        styleEngine().setUsesRemUnit(true);
 
     updateStyle(change);
 
     // As a result of the style recalculation, the currently hovered element might have been
     // detached (for example, by setting display:none in the :hover style), schedule another mouseMove event
     // to check if any other elements ended up under the mouse pointer due to re-layout.
     if (hoverNode() && !hoverNode()->renderer() && frame())
         frame()->eventHandler().dispatchFakeMouseMoveEventSoon();
 
     if (m_focusedElement && !m_focusedElement->isFocusable())
@@ skipping 48 matching lines @@
         while (dirtyElementsForLayerUpdate())
             documentElement->recalcStyle(NoChange);
     }
 
     ensureStyleResolver().printStats();
 
     view()->recalcOverflowAfterStyleChange();
 
     clearChildNeedsStyleRecalc();
 
-    if (m_styleEngine->hasResolver()) {
+    if (styleEngine().hasResolver()) {
         // Pseudo element removal and similar may only work with these flags still set. Reset them after the style recalc.
-        StyleResolver& resolver = m_styleEngine->ensureResolver();
-        m_styleEngine->resetCSSFeatureFlags(resolver.ensureUpdatedRuleFeatureSet());
+        StyleResolver& resolver = styleEngine().ensureResolver();
+        styleEngine().resetCSSFeatureFlags(resolver.ensureUpdatedRuleFeatureSet());
         resolver.clearStyleSharingList();
     }
 
     ASSERT(!needsStyleRecalc());
     ASSERT(!childNeedsStyleRecalc());
     ASSERT(inStyleRecalc());
     m_lifecycle.advanceTo(DocumentLifecycle::StyleClean);
 }
 
 void Document::updateRenderTreeForNodeIfNeeded(Node* node)
@@ skipping 64 matching lines @@
 }
 
 // FIXME: This is a bad idea and needs to be removed eventually.
 // Other browsers load stylesheets before they continue parsing the web page.
 // Since we don't, we can run JavaScript code that needs answers before the
 // stylesheets are loaded. Doing a layout ignoring the pending stylesheets
 // lets us get reasonable answers. The long term solution to this problem is
 // to instead suspend JavaScript execution.
 void Document::updateLayoutIgnorePendingStylesheets(Document::RunPostLayoutTasks runPostLayoutTasks)
 {
-    StyleEngine::IgnoringPendingStylesheet ignoring(m_styleEngine.get());
+    StyleEngine::IgnoringPendingStylesheet ignoring(styleEngine());
 
-    if (m_styleEngine->hasPendingSheets()) {
+    if (styleEngine().hasPendingSheets()) {
         // FIXME: We are willing to attempt to suppress painting with outdated style info only once.
         // Our assumption is that it would be dangerous to try to stop it a second time, after page
         // content has already been loaded and displayed with accurate style information. (Our
         // suppression involves blanking the whole page at the moment. If it were more refined, we
         // might be able to do something better.) It's worth noting though that this entire method
         // is a hack, since what we really want to do is suspend JS instead of doing a layout with
         // inaccurate information.
         HTMLElement* bodyElement = body();
         if (bodyElement && !bodyElement->renderer() && m_pendingSheetLayout == NoLayoutWithPendingSheets) {
             m_pendingSheetLayout = DidLayoutWithPendingSheets;
             styleResolverChanged();
         } else if (m_hasNodesWithPlaceholderStyle) {
             // If new nodes have been added or style recalc has been done with style sheets still
             // pending, some nodes may not have had their real style calculated yet. Normally this
             // gets cleaned when style sheets arrive but here we need up-to-date style immediately.
             updateRenderTree(Force);
         }
     }
 
     updateLayout();
 
     if (runPostLayoutTasks == RunPostLayoutTasksSynchronously && view())
         view()->flushAnyPendingPostLayoutTasks();
 }
 
 PassRefPtr<LayoutStyle> Document::styleForElementIgnoringPendingStylesheets(Element* element)
 {
     ASSERT_ARG(element, element->document() == this);
-    StyleEngine::IgnoringPendingStylesheet ignoring(m_styleEngine.get());
+    StyleEngine::IgnoringPendingStylesheet ignoring(styleEngine());
     return ensureStyleResolver().styleForElement(element, element->parentNode() ? element->parentNode()->computedStyle() : 0);
 }
 
 PassRefPtr<LayoutStyle> Document::styleForPage(int pageIndex)
 {
     updateDistribution();
     return ensureStyleResolver().styleForPage(pageIndex);
 }
 
 bool Document::isPageBoxVisible(int pageIndex)
@@ skipping 104 matching lines @@
 StyleResolver* Document::styleResolver() const
 {
     return m_styleEngine->resolver();
 }
 
 StyleResolver& Document::ensureStyleResolver() const
 {
     return m_styleEngine->ensureResolver();
 }
 
-void Document::clearStyleResolver()
-{
-    m_styleEngine->clearResolver();
-}
-
 void Document::attach(const AttachContext& context)
 {
     ASSERT(m_lifecycle.state() == DocumentLifecycle::Inactive);
     ASSERT(!m_axObjectCache || this != &axObjectCacheOwner());
 
     m_layoutView = new LayoutView(this);
     setRenderer(m_layoutView);
 
     m_layoutView->setIsInWindow(true);
     m_layoutView->setStyle(StyleResolver::styleForDocument(*this));
@@ skipping 57 matching lines @@
         RefPtrWillBeRawPtr<Element> oldFocusedElement = m_focusedElement;
         m_focusedElement = nullptr;
         if (frameHost())
             frameHost()->chrome().focusedNodeChanged(oldFocusedElement.get(), nullptr);
 
     }
 
     m_layoutView = 0;
     ContainerNode::detach(context);
 
-    m_styleEngine->didDetach();
+    styleEngine().didDetach();
 
     frameHost()->eventHandlerRegistry().documentDetached(*this);
 
     // This is required, as our LocalFrame might delete itself as soon as it detaches
     // us. However, this violates Node::detach() semantics, as it's never
     // possible to re-attach. Eventually Document::detach() should be renamed,
     // or this setting of the frame to 0 could be made explicit in each of the
     // callers of Document::detach().
     m_frame = nullptr;
 
@@ skipping 776 matching lines @@
 }
 
 void Document::processHttpEquivDefaultStyle(const AtomicString& content)
 {
     // The preferred style set has been overridden as per section
     // 14.3.2 of the HTML4.0 specification. We need to update the
     // sheet used variable and then update our style selector.
     // For more info, see the test at:
     // http://www.hixie.ch/tests/evil/css/import/main/preferred.html
     // -dwh
-    m_styleEngine->setSelectedStylesheetSetName(content);
-    m_styleEngine->setPreferredStylesheetSetName(content);
+    styleEngine().setSelectedStylesheetSetName(content);
+    styleEngine().setPreferredStylesheetSetName(content);
     styleResolverChanged();
 }
 
 void Document::processHttpEquivRefresh(const AtomicString& content)
 {
     maybeHandleHttpRefresh(content, HttpRefreshFromMetaTag);
 }
 
 void Document::maybeHandleHttpRefresh(const String& content, HttpRefreshType httpRefreshType)
 {
@@ skipping 317 matching lines @@
     return m_styleEngine->preferredStylesheetSetName();
 }
 
 String Document::selectedStylesheetSet() const
 {
     return m_styleEngine->selectedStylesheetSetName();
 }
 
 void Document::setSelectedStylesheetSet(const String& aString)
 {
-    m_styleEngine->setSelectedStylesheetSetName(aString);
+    styleEngine().setSelectedStylesheetSetName(aString);
     styleResolverChanged();
 }
 
 void Document::evaluateMediaQueryListIfNeeded()
 {
     if (!m_evaluateMediaQueriesOnStyleRecalc)
         return;
     evaluateMediaQueryList();
     m_evaluateMediaQueriesOnStyleRecalc = false;
 }
 
 void Document::evaluateMediaQueryList()
 {
     if (m_mediaQueryMatcher)
         m_mediaQueryMatcher->mediaFeaturesChanged();
 }
 
 void Document::notifyResizeForViewportUnits()
 {
     if (m_mediaQueryMatcher)
         m_mediaQueryMatcher->viewportChanged();
     if (!hasViewportUnits())
         return;
     ensureStyleResolver().notifyResizeForViewportUnits();
     setNeedsStyleRecalcForViewportUnits();
 }
 
 void Document::styleResolverChanged(StyleResolverUpdateMode updateMode)
 {
-    // styleResolverChanged() can be invoked during Document destruction.
-    // We just skip that case.
-    if (!m_styleEngine)
-        return;
+    styleEngine().resolverChanged(updateMode);
 
-    m_styleEngine->resolverChanged(updateMode);
-
-    if (didLayoutWithPendingStylesheets() && !m_styleEngine->hasPendingSheets()) {
+    if (didLayoutWithPendingStylesheets() && !styleEngine().hasPendingSheets()) {
         // We need to manually repaint because we avoid doing all repaints in layout or style
         // recalc while sheets are still loading to avoid FOUC.
         m_pendingSheetLayout = IgnoreLayoutWithPendingSheets;
 
         ASSERT(layoutView() || importsController());
         if (layoutView())
             layoutView()->invalidatePaintForViewAndCompositedLayers();
     }
 }
 
@@ skipping 2098 matching lines @@
 {
     return m_frame ? m_frame->devicePixelRatio() : 1.0;
 }
 
 void Document::removedStyleSheet(StyleSheet* sheet, StyleResolverUpdateMode updateMode)
 {
     // If we're in document teardown, then we don't need this notification of our sheet's removal.
     // styleResolverChanged() is needed even when the document is inactive so that
     // imported docuements (which is inactive) notifies the change to the master document.
     if (isActive())
-        styleEngine()->modifiedStyleSheet(sheet);
+        styleEngine().modifiedStyleSheet(sheet);
     styleResolverChanged(updateMode);
 }
 
 void Document::modifiedStyleSheet(StyleSheet* sheet, StyleResolverUpdateMode updateMode)
 {
     // If we're in document teardown, then we don't need this notification of our sheet's removal.
     // styleResolverChanged() is needed even when the document is inactive so that
     // imported docuements (which is inactive) notifies the change to the master document.
     if (isActive())
-        styleEngine()->modifiedStyleSheet(sheet);
+        styleEngine().modifiedStyleSheet(sheet);
     styleResolverChanged(updateMode);
 }
 
 TextAutosizer* Document::textAutosizer()
 {
     if (!m_textAutosizer)
         m_textAutosizer = TextAutosizer::create(this);
     return m_textAutosizer.get();
 }
 
@@ skipping 158 matching lines @@
 {
     for (const LiveNodeListBase* list : m_listsInvalidatedAtDocument)
         list->invalidateCacheForAttribute(attrName);
 }
 
 void Document::platformColorsChanged()
 {
     if (!isActive())
         return;
 
-    styleEngine()->platformColorsChanged();
+    styleEngine().platformColorsChanged();
 }
 
 void Document::clearWeakMembers(Visitor* visitor)
 {
     if (m_axObjectCache)
         m_axObjectCache->clearWeakMembers(visitor);
 }
 
 v8::Handle<v8::Object> Document::wrap(v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
@@ skipping 95 matching lines @@
 #ifndef NDEBUG
 using namespace blink;
 void showLiveDocumentInstances()
 {
     WeakDocumentSet& set = liveDocumentSet();
     fprintf(stderr, "There are %u documents currently alive:\n", set.size());
     for (Document* document : set)
         fprintf(stderr, "- Document %p URL: %s\n", document, document->url().string().utf8().data());
 }
 #endif