When there are no more stylesheets schedule the recalc async

Source/core/dom/DocumentStyleSheetCollection.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 333 matching lines @@
             }
 
             if (rel.contains("alternate") && title.isEmpty())
                 sheet = 0;
         }
         if (sheet)
             sheets.append(sheet);
     }
 }
 
-void DocumentStyleSheetCollection::analyzeStyleSheetChange(UpdateFlag updateFlag, const Vector<RefPtr<CSSStyleSheet> >& newStylesheets, StyleResolverUpdateType& styleResolverUpdateType, bool& requiresFullStyleRecalc)
+DocumentStyleSheetCollection::UpdateAction DocumentStyleSheetCollection::analyzeStyleSheetChange(StyleResolverUpdateMode updateMode, const Vector<RefPtr<CSSStyleSheet> >& newStylesheets, bool& requiresFullStyleRecalc)
 {
-    styleResolverUpdateType = Reconstruct;
-    requiresFullStyleRecalc = true;
-    
+    // FIXME: Updating the active loading sheet state shouldn't be in this method.
+
     // Stylesheets of <style> elements that @import stylesheets are active but loading. We need to trigger a full recalc when such loads are done.
     bool hasActiveLoadingStylesheet = false;
     unsigned newStylesheetCount = newStylesheets.size();
     for (unsigned i = 0; i < newStylesheetCount; ++i) {
         if (newStylesheets[i]->isLoading())
             hasActiveLoadingStylesheet = true;
     }
     if (m_hadActiveLoadingStylesheet && !hasActiveLoadingStylesheet) {
         m_hadActiveLoadingStylesheet = false;
-        return;
+        return Reconstruct;
     }
     m_hadActiveLoadingStylesheet = hasActiveLoadingStylesheet;
 
-    if (updateFlag != OptimizedUpdate)
-        return;
+    if (updateMode != OptimizedStyleUpdate)
+        return Reconstruct;
     if (!m_document->styleResolverIfExists())
-        return;
+        return Reconstruct;
 
     // Find out which stylesheets are new.
     unsigned oldStylesheetCount = m_activeAuthorStyleSheets.size();
     if (newStylesheetCount < oldStylesheetCount)
-        return;
+        return Reconstruct;
     Vector<StyleSheetContents*> addedSheets;
     unsigned newIndex = 0;
     for (unsigned oldIndex = 0; oldIndex < oldStylesheetCount; ++oldIndex) {
         if (newIndex >= newStylesheetCount)
-            return;
+            return Reconstruct;
         while (m_activeAuthorStyleSheets[oldIndex] != newStylesheets[newIndex]) {
             addedSheets.append(newStylesheets[newIndex]->contents());
             ++newIndex;
             if (newIndex == newStylesheetCount)
-                return;
+                return Reconstruct;
         }
         ++newIndex;
     }
     bool hasInsertions = !addedSheets.isEmpty();
     while (newIndex < newStylesheetCount) {
         addedSheets.append(newStylesheets[newIndex]->contents());
         ++newIndex;
     }
+
+    // If we don't have a body yet it's unlikely there's enough nodes to warrant
+    // doing analysis. If there's place holder styles we do a full recalc to turn
+    // them into real styles.
+    //
+    // FIXME: It's not clear why analysis isn't safe for placeholder styles.
+    if (m_document->body() && !m_document->hasNodesWithPlaceholderStyle()) {
+        StyleInvalidationAnalysis invalidationAnalysis(addedSheets);
+        if (!invalidationAnalysis.dirtiesAllStyle()) {
+            invalidationAnalysis.invalidateStyle(m_document);
+            requiresFullStyleRecalc = false;
+        }
+    }
+
     // If all new sheets were added at the end of the list we can just add them to existing StyleResolver.
     // If there were insertions we need to re-add all the stylesheets so rules are ordered correctly.
-    styleResolverUpdateType = hasInsertions ? Reset : Additive;
-
-    // If we are already parsing the body and so may have significant amount of elements, put some effort into trying to avoid style recalcs.
-    if (!m_document->body() || m_document->hasNodesWithPlaceholderStyle())
-        return;
-    StyleInvalidationAnalysis invalidationAnalysis(addedSheets);
-    if (invalidationAnalysis.dirtiesAllStyle())
-        return;
-    invalidationAnalysis.invalidateStyle(m_document);
-    requiresFullStyleRecalc = false;
+    return hasInsertions ? Reset : Append;
 }
 
 static bool styleSheetsUseRemUnits(const Vector<RefPtr<CSSStyleSheet> >& sheets)
 {
     for (unsigned i = 0; i < sheets.size(); ++i) {
         if (sheets[i]->contents()->usesRemUnits())
             return true;
     }
     return false;
 }
@@ skipping 10 matching lines @@
 }
 
 static void collectActiveCSSStyleSheetsFromSeamlessParents(Vector<RefPtr<CSSStyleSheet> >& sheets, Document* document)
 {
     HTMLIFrameElement* seamlessParentIFrame = document->seamlessParentIFrame();
     if (!seamlessParentIFrame)
         return;
     sheets.append(seamlessParentIFrame->document()->styleSheetCollection()->activeAuthorStyleSheets());
 }
 
-bool DocumentStyleSheetCollection::updateActiveStyleSheets(UpdateFlag updateFlag)
+bool DocumentStyleSheetCollection::updateActiveStyleSheets(StyleResolverUpdateMode updateMode)
 {
     if (m_document->inStyleRecalc()) {
         // SVG <use> element may manage to invalidate style selector in the middle of a style recalc.
         // https://bugs.webkit.org/show_bug.cgi?id=54344
         // FIXME: This should be fixed in SVG and the call site replaced by ASSERT(!m_inStyleRecalc).
         m_needsUpdateActiveStylesheetsOnStyleRecalc = true;
         m_document->scheduleForcedStyleRecalc();
         return false;
+    }
 
-    }
     if (!m_document->renderer() || !m_document->attached())
         return false;
 
     Vector<RefPtr<StyleSheet> > activeStyleSheets;
     collectActiveStyleSheets(activeStyleSheets);
 
     Vector<RefPtr<CSSStyleSheet> > activeCSSStyleSheets;
     activeCSSStyleSheets.append(injectedAuthorStyleSheets());
     activeCSSStyleSheets.append(documentAuthorStyleSheets());
     collectActiveCSSStyleSheetsFromSeamlessParents(activeCSSStyleSheets, m_document);
     filterEnabledCSSStyleSheets(activeCSSStyleSheets, activeStyleSheets);
 
-    StyleResolverUpdateType styleResolverUpdateType;
-    bool requiresFullStyleRecalc;
-    analyzeStyleSheetChange(updateFlag, activeCSSStyleSheets, styleResolverUpdateType, requiresFullStyleRecalc);
+    bool requiresFullStyleRecalc = true;
+    UpdateAction action = analyzeStyleSheetChange(updateMode, activeCSSStyleSheets, requiresFullStyleRecalc);
 
-    if (styleResolverUpdateType == Reconstruct)
+    switch (action) {
+    case Reconstruct:
         m_document->clearStyleResolver();
-    else {
-        StyleResolver* styleResolver = m_document->styleResolver();
-        if (styleResolverUpdateType == Reset) {
-            styleResolver->ruleSets().resetAuthorStyle();
-            styleResolver->appendAuthorStyleSheets(0, activeCSSStyleSheets);
-        } else {
-            ASSERT(styleResolverUpdateType == Additive);
-            styleResolver->appendAuthorStyleSheets(m_activeAuthorStyleSheets.size(), activeCSSStyleSheets);
-        }
+        break;
+    case Reset:
+        m_document->styleResolver()->ruleSets().resetAuthorStyle();
+        m_document->styleResolver()->appendAuthorStyleSheets(0, activeCSSStyleSheets);
         resetCSSFeatureFlags();
+        break;
+    case Append:
+        m_document->styleResolver()->appendAuthorStyleSheets(m_activeAuthorStyleSheets.size(), activeCSSStyleSheets);
+        resetCSSFeatureFlags();
+        break;
     }
+
     m_activeAuthorStyleSheets.swap(activeCSSStyleSheets);
     InspectorInstrumentation::activeStyleSheetsUpdated(m_document, activeStyleSheets);
     m_styleSheetsForStyleSheetList.swap(activeStyleSheets);
 
     m_usesRemUnits = styleSheetsUseRemUnits(m_activeAuthorStyleSheets);
     m_needsUpdateActiveStylesheetsOnStyleRecalc = false;
 
     m_document->notifySeamlessChildDocumentsOfStylesheetUpdate();
 
     return requiresFullStyleRecalc;
 }
 
 void DocumentStyleSheetCollection::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::DOM);
     info.addMember(m_pageUserSheet, "pageUserSheet");
     info.addMember(m_injectedUserStyleSheets, "injectedUserStyleSheets");
     info.addMember(m_injectedAuthorStyleSheets, "injectedAuthorStyleSheets");
     info.addMember(m_userStyleSheets, "userStyleSheets");
     info.addMember(m_authorStyleSheets, "authorStyleSheets");
     info.addMember(m_activeAuthorStyleSheets, "activeAuthorStyleSheets");
     info.addMember(m_styleSheetsForStyleSheetList, "styleSheetsForStyleSheetList");
     info.addMember(m_styleSheetCandidateNodes, "styleSheetCandidateNodes");
     info.addMember(m_preferredStylesheetSetName, "preferredStylesheetSetName");
     info.addMember(m_selectedStylesheetSetName, "selectedStylesheetSetName");
     info.addMember(m_document, "document");
 }
 
 }