Rename updateStyle to updateRenderTree

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 1503 matching lines @@
 
 PassRefPtr<TreeWalker> Document::createTreeWalker(Node* root, unsigned whatToShow, PassRefPtr<NodeFilter> filter, ExceptionState& exceptionState)
 {
     if (!root) {
         exceptionState.throwDOMException(NotSupportedError, ExceptionMessages::argumentNullOrIncorrectType(1, "Node"));
         return nullptr;
     }
     return TreeWalker::create(root, whatToShow, filter);
 }
 
-bool Document::shouldCallRecalcStyleForDocument()
+bool Document::needsRenderTreeUpdate() const
 {
     if (!isActive() || !view())
         return false;
     if (needsStyleRecalc() || childNeedsStyleRecalc())
         return true;
     if (childNeedsDistributionRecalc())
         return true;
     if (!m_useElementsNeedingUpdate.isEmpty())
         return true;
     if (!m_layerUpdateElements.isEmpty())
         return true;
     if (childNeedsStyleInvalidation())
         return true;
     return false;
 }
 
-bool Document::shouldScheduleStyleRecalc()
+bool Document::shouldScheduleRenderTreeUpdate() const
 {
     if (!isActive())
         return false;
     if (hasPendingStyleRecalc())
         return false;
     if (inStyleRecalc())
         return false;
     // InPreLayout will recalc style itself. There's no reason to schedule another recalc.
     if (m_lifecycle.state() == DocumentLifecycle::InPreLayout)
         return false;
     if (!shouldScheduleLayout())
         return false;
     return true;
 }
 
-void Document::scheduleStyleRecalc()
+void Document::scheduleRenderTreeUpdate()
 {
-    if (!shouldScheduleStyleRecalc())
+    if (!shouldScheduleRenderTreeUpdate())
         return;
 
-    ASSERT(shouldCallRecalcStyleForDocument());
+    ASSERT(needsRenderTreeUpdate());
 
     page()->animator().scheduleVisualUpdate();
     m_lifecycle.advanceTo(DocumentLifecycle::StyleRecalcPending);
 
     InspectorInstrumentation::didScheduleStyleRecalculation(this);
 }
 
 bool Document::hasPendingForcedStyleRecalc() const
 {
     return hasPendingStyleRecalc() && !inStyleRecalc() && styleChangeType() >= SubtreeStyleChange;
@@ skipping 126 matching lines @@
                 body->setNeedsStyleRecalc(SubtreeStyleChange);
         }
     }
 
     if (RenderStyle* style = documentElement()->renderStyle()) {
         if (style->direction() != rootDirection || style->writingMode() != rootWritingMode)
             documentElement()->setNeedsStyleRecalc(SubtreeStyleChange);
     }
 }
 
-void Document::updateStyleIfNeeded()
-{
-    updateStyle(NoChange);
-}
-
-// FIXME: We need a better name than updateStyleIfNeeded. It's performing style invalidation,
-// style recalc, distribution and <use> shadow tree creation.
-void Document::updateStyle(StyleRecalcChange change)
+void Document::updateRenderTree(StyleRecalcChange change)
 {
     ASSERT(isMainThread());
 
-    if (change != Force && !shouldCallRecalcStyleForDocument())
+    if (change != Force && !needsRenderTreeUpdate())
         return;
 
     if (inStyleRecalc())
         return;
 
     // Entering here from inside layout or paint would be catastrophic since recalcStyle can
     // tear down the render tree or (unfortunately) run script. Kill the whole renderer if
     // someone managed to get into here from inside layout or paint.
     RELEASE_ASSERT(!view()->isInPerformLayout());
     RELEASE_ASSERT(!view()->isPainting());
 
     // Script can run below in WidgetUpdates, so protect the LocalFrame.
     RefPtr<LocalFrame> protect(m_frame);
 
-    TRACE_EVENT0("webkit", "Document::recalcStyle");
-    TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "RecalcStyle");
+    TRACE_EVENT0("webkit", "Document::updateRenderTree");
+    TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "UpdateRenderTree");
 
     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willRecalculateStyle(this);
 
     updateDistributionIfNeeded();
     updateUseShadowTreesIfNeeded();
     updateStyleInvalidationIfNeeded();
 
-    if (m_evaluateMediaQueriesOnStyleRecalc) {
-        m_evaluateMediaQueriesOnStyleRecalc = false;
-        evaluateMediaQueryList();
-    }
+    // This executes media query listeners which runs script.
+    evaluateMediaQueryListIfNeeded();
 
     // 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 DOMWindow 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);
 
-    {
-        RenderWidget::UpdateSuspendScope suspendWidgetHierarchyUpdates;
-        m_lifecycle.advanceTo(DocumentLifecycle::InStyleRecalc);
-
-        if (styleChangeType() >= SubtreeStyleChange)
-            change = Force;
-
-        // FIXME: Cannot access the ensureStyleResolver() before calling styleForDocument below because
-        // apparently the StyleResolver's constructor has side effects. We should fix it.
-        // See printing/setPrinting.html, printing/width-overflow.html though they only fail on
-        // mac when accessing the resolver by what appears to be a viewport size difference.
-
-        if (change == Force) {
-            m_hasNodesWithPlaceholderStyle = false;
-            RefPtr<RenderStyle> documentStyle = StyleResolver::styleForDocument(*this, m_styleEngine->fontSelector());
-            StyleRecalcChange localChange = RenderStyle::compare(documentStyle.get(), renderView()->style());
-            if (localChange != NoChange)
-                renderView()->setStyle(documentStyle.release());
-        }
-
-        clearNeedsStyleRecalc();
-
-        // Uncomment to enable printing of statistics about style sharing and the matched property cache.
-        // Optionally pass StyleResolver::ReportSlowStats to print numbers that require crawling the
-        // entire DOM (where collecting them is very slow).
-        // FIXME: Expose this as a runtime flag.
-        // ensureStyleResolver().enableStats(/*StyleResolver::ReportSlowStats*/);
-
-        if (StyleResolverStats* stats = ensureStyleResolver().stats())
-            stats->reset();
-
-        if (Element* documentElement = this->documentElement()) {
-            inheritHtmlAndBodyElementStyles(change);
-            dirtyElementsForLayerUpdate();
-            if (documentElement->shouldCallRecalcStyle(change))
-                documentElement->recalcStyle(change);
-            while (dirtyElementsForLayerUpdate())
-                documentElement->recalcStyle(NoChange);
-        }
-
-        ensureStyleResolver().printStats();
-
-        view()->updateCompositingLayersAfterStyleChange();
-
-        clearChildNeedsStyleRecalc();
-
-        if (m_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());
-            resolver.clearStyleSharingList();
-        }
-
-        ASSERT(!needsStyleRecalc());
-        ASSERT(!childNeedsStyleRecalc());
-        ASSERT(inStyleRecalc());
-        m_lifecycle.advanceTo(DocumentLifecycle::StyleClean);
-    }
+    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())
         clearFocusedElementSoon();
 
 #if ENABLE(SVG_FONTS)
     if (svgExtensions())
         accessSVGExtensions().removePendingSVGFontFaceElementsForRemoval();
 #endif
     InspectorInstrumentation::didRecalculateStyle(cookie);
 }
 
+void Document::updateStyle(StyleRecalcChange change)
+{
+    TRACE_EVENT0("webkit", "Document::updateStyle");
+
+    RenderWidget::UpdateSuspendScope suspendWidgetHierarchyUpdates;
+    m_lifecycle.advanceTo(DocumentLifecycle::InStyleRecalc);
+
+    if (styleChangeType() >= SubtreeStyleChange)
+        change = Force;
+
+    // FIXME: Cannot access the ensureStyleResolver() before calling styleForDocument below because
+    // apparently the StyleResolver's constructor has side effects. We should fix it.
+    // See printing/setPrinting.html, printing/width-overflow.html though they only fail on
+    // mac when accessing the resolver by what appears to be a viewport size difference.
+
+    if (change == Force) {
+        m_hasNodesWithPlaceholderStyle = false;
+        RefPtr<RenderStyle> documentStyle = StyleResolver::styleForDocument(*this, m_styleEngine->fontSelector());
+        StyleRecalcChange localChange = RenderStyle::compare(documentStyle.get(), renderView()->style());
+        if (localChange != NoChange)
+            renderView()->setStyle(documentStyle.release());
+    }
+
+    clearNeedsStyleRecalc();
+
+    // Uncomment to enable printing of statistics about style sharing and the matched property cache.
+    // Optionally pass StyleResolver::ReportSlowStats to print numbers that require crawling the
+    // entire DOM (where collecting them is very slow).
+    // FIXME: Expose this as a runtime flag.
+    // ensureStyleResolver().enableStats(/*StyleResolver::ReportSlowStats*/);
+
+    if (StyleResolverStats* stats = ensureStyleResolver().stats())
+        stats->reset();
+
+    if (Element* documentElement = this->documentElement()) {
+        inheritHtmlAndBodyElementStyles(change);
+        dirtyElementsForLayerUpdate();
+        if (documentElement->shouldCallRecalcStyle(change))
+            documentElement->recalcStyle(change);
+        while (dirtyElementsForLayerUpdate())
+            documentElement->recalcStyle(NoChange);
+    }
+
+    ensureStyleResolver().printStats();
+
+    view()->updateCompositingLayersAfterStyleChange();
+
+    clearChildNeedsStyleRecalc();
+
+    if (m_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());
+        resolver.clearStyleSharingList();
+    }
+
+    ASSERT(!needsStyleRecalc());
+    ASSERT(!childNeedsStyleRecalc());
+    ASSERT(inStyleRecalc());
+    m_lifecycle.advanceTo(DocumentLifecycle::StyleClean);
+}
+
 void Document::updateStyleForNodeIfNeeded(Node* node)
 {
-    if (!shouldCallRecalcStyleForDocument())
+    if (!needsRenderTreeUpdate())
         return;
 
     // At this point, we know that we need to recalc some style on the document in order to fully update styles.
     // However, style on 'node' only needs to be recalculated if a global recomputation is needed, or a node on
     // the path from 'node' to the root needs style recalc.
 
     // Global needed.
     bool needsRecalc = needsStyleRecalc() || childNeedsDistributionRecalc() || !m_useElementsNeedingUpdate.isEmpty() || childNeedsStyleInvalidation();
 
     // On the path.
@@ skipping 63 matching lines @@
         // 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(RecalcStyleImmediately);
         } 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.
-            updateStyle(Force);
+            updateRenderTree(Force);
         }
     }
 
     updateLayout();
 
     if (runPostLayoutTasks == RunPostLayoutTasksSynchronously && view())
         view()->flushAnyPendingPostLayoutTasks();
 }
 
 PassRefPtr<RenderStyle> Document::styleForElementIgnoringPendingStylesheets(Element* element)
@@ skipping 71 matching lines @@
     m_layerUpdateElements.clear();
     return true;
 }
 
 void Document::scheduleLayerUpdate(Element& element)
 {
     if (element.styleChangeType() == NeedsReattachStyleChange)
         return;
     element.setNeedsLayerUpdate();
     m_layerUpdateElements.add(&element);
-    scheduleStyleRecalc();
+    scheduleRenderTreeUpdate();
 }
 
 void Document::unscheduleLayerUpdate(Element& element)
 {
     element.clearNeedsLayerUpdate();
     m_layerUpdateElements.remove(&element);
 }
 
 void Document::scheduleUseShadowTreeUpdate(SVGUseElement& element)
 {
     m_useElementsNeedingUpdate.add(&element);
-    scheduleStyleRecalc();
+    scheduleRenderTreeUpdate();
 }
 
 void Document::unscheduleUseShadowTreeUpdate(SVGUseElement& element)
 {
     m_useElementsNeedingUpdate.remove(&element);
 }
 
 void Document::updateUseShadowTreesIfNeeded()
 {
     if (m_useElementsNeedingUpdate.isEmpty())
@@ skipping 565 matching lines @@
 }
 
 void Document::setParsing(bool b)
 {
     m_isParsing = b;
 
     if (m_isParsing && !m_elementDataCache)
         m_elementDataCache = ElementDataCache::create();
 }
 
-bool Document::shouldScheduleLayout()
+bool Document::shouldScheduleLayout() const
 {
     // This function will only be called when FrameView thinks a layout is needed.
     // This enforces a couple extra rules.
     //
     //    (a) Only schedule a layout once the stylesheets are loaded.
     //    (b) Only schedule layout once we have a body element.
 
     return (haveStylesheetsAndImportsLoaded() && body())
         || (documentElement() && !isHTMLHtmlElement(*documentElement()));
 }
@@ skipping 660 matching lines @@
 {
     return m_styleEngine->selectedStylesheetSetName();
 }
 
 void Document::setSelectedStylesheetSet(const String& aString)
 {
     m_styleEngine->setSelectedStylesheetSetName(aString);
     styleResolverChanged(RecalcStyleDeferred);
 }
 
+void Document::evaluateMediaQueryListIfNeeded()
+{
+    if (!m_evaluateMediaQueriesOnStyleRecalc)
+        return;
+    evaluateMediaQueryList();
+    m_evaluateMediaQueriesOnStyleRecalc = false;
+}
+
 void Document::evaluateMediaQueryList()
 {
     if (m_mediaQueryMatcher)
         m_mediaQueryMatcher->styleResolverChanged();
 }
 
 void Document::notifyResizeForViewportUnits()
 {
     if (!hasViewportUnits())
         return;
@@ skipping 2193 matching lines @@
 }
 
 void Document::invalidateNodeListCaches(const QualifiedName* attrName)
 {
     HashSet<LiveNodeListBase*>::iterator end = m_listsInvalidatedAtDocument.end();
     for (HashSet<LiveNodeListBase*>::iterator it = m_listsInvalidatedAtDocument.begin(); it != end; ++it)
         (*it)->invalidateCache(attrName);
 }
 
 } // namespace WebCore