Revert of Collect active stylesheets and and apply asynchronously.

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 133 matching lines @@
 }
 
 CSSStyleSheet& StyleEngine::ensureInspectorStyleSheet() {
   if (m_inspectorStyleSheet)
     return *m_inspectorStyleSheet;
 
   StyleSheetContents* contents =
       StyleSheetContents::create(CSSParserContext(*m_document, nullptr));
   m_inspectorStyleSheet = CSSStyleSheet::create(contents, *m_document);
   markDocumentDirty();
-  // TODO(rune@opera.com): Making the active stylesheets up-to-date here is
-  // required by some inspector tests, at least. I theory this should not be
-  // necessary. Need to investigate to figure out if/why.
-  updateActiveStyle();
+  resolverChanged(AnalyzedStyleUpdate);
   return *m_inspectorStyleSheet;
 }
 
 void StyleEngine::addPendingSheet(StyleEngineContext& context) {
   m_pendingScriptBlockingStylesheets++;
 
   context.addingPendingSheet(document());
   if (context.addedPendingSheetBeforeBody())
     m_pendingRenderBlockingStylesheets++;
 }
@@ skipping 95 matching lines @@
   return m_allTreeScopesDirty || !m_dirtyTreeScopes.isEmpty();
 }
 
 void StyleEngine::mediaQueryAffectingValueChanged(
     UnorderedTreeScopeSet& treeScopes) {
   for (TreeScope* treeScope : treeScopes) {
     DCHECK(treeScope != m_document);
     ShadowTreeStyleSheetCollection* collection =
         toShadowTreeStyleSheetCollection(styleSheetCollectionFor(*treeScope));
     DCHECK(collection);
-    if (collection->mediaQueryAffectingValueChanged())
-      setNeedsActiveStyleUpdate(*treeScope);
+    collection->clearMediaQueryRuleSetStyleSheets();
   }
 }
 
 void StyleEngine::mediaQueryAffectingValueChanged() {
-  if (documentStyleSheetCollection().mediaQueryAffectingValueChanged())
-    setNeedsActiveStyleUpdate(document());
+  resolverChanged(FullStyleUpdate);
+  documentStyleSheetCollection().clearMediaQueryRuleSetStyleSheets();
   mediaQueryAffectingValueChanged(m_activeTreeScopes);
   if (m_resolver)
     m_resolver->updateMediaType();
 }
 
 void StyleEngine::updateStyleSheetsInImport(
     DocumentStyleSheetCollector& parentCollector) {
   DCHECK(!isMaster());
   HeapVector<Member<StyleSheet>> sheetsForList;
   ImportedDocumentStyleSheetCollector subcollector(parentCollector,
                                                    sheetsForList);
-  documentStyleSheetCollection().collectStyleSheets(subcollector);
+  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();
+  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() {
-  if (!needsActiveStyleSheetUpdate())
-    return;
-
+void StyleEngine::updateActiveStyleSheets(StyleResolverUpdateMode updateMode) {
   DCHECK(isMaster());
   DCHECK(!document().inStyleRecalc());
-  DCHECK(document().isActive());
+
+  if (!document().isActive())
+    return;
 
   TRACE_EVENT0("blink,blink_style", "StyleEngine::updateActiveStyleSheets");
 
   if (shouldUpdateDocumentStyleSheetCollection())
-    documentStyleSheetCollection().updateActiveStyleSheets();
+    documentStyleSheetCollection().updateActiveStyleSheets(*this, updateMode);
 
   if (shouldUpdateShadowTreeStyleSheetCollection()) {
     UnorderedTreeScopeSet treeScopesRemoved;
 
     if (m_allTreeScopesDirty) {
       for (TreeScope* treeScope : m_activeTreeScopes)
-        updateActiveStyleSheetsInShadow(treeScope, treeScopesRemoved);
+        updateActiveStyleSheetsInShadow(updateMode, treeScope,
+                                        treeScopesRemoved);
     } else {
       for (TreeScope* treeScope : m_dirtyTreeScopes)
-        updateActiveStyleSheetsInShadow(treeScope, treeScopesRemoved);
+        updateActiveStyleSheetsInShadow(updateMode, treeScope,
+                                        treeScopesRemoved);
     }
     for (TreeScope* treeScope : treeScopesRemoved)
       m_activeTreeScopes.remove(treeScope);
   }
 
   InspectorInstrumentation::activeStyleSheetsUpdated(m_document);
 
   m_dirtyTreeScopes.clear();
   m_documentScopeDirty = false;
   m_allTreeScopesDirty = false;
 }
 
+void StyleEngine::updateActiveStyleSheets() {
+  // TODO(rune@opera.com): collect ActiveStyleSheets here.
+}
+
 void StyleEngine::updateViewport() {
   if (m_viewportResolver)
     m_viewportResolver->updateViewport(documentStyleSheetCollection());
 }
 
 bool StyleEngine::needsActiveStyleUpdate() const {
-  return (m_viewportResolver && m_viewportResolver->needsUpdate()) ||
-         needsActiveStyleSheetUpdate() || m_globalRuleSet.isDirty();
+  return m_viewportResolver && m_viewportResolver->needsUpdate();
 }
 
 void StyleEngine::updateActiveStyle() {
-  DCHECK(document().isActive());
   updateViewport();
   updateActiveStyleSheets();
   m_globalRuleSet.update(document());
 }
 
-const ActiveStyleSheetVector StyleEngine::activeStyleSheetsForInspector() {
-  if (document().isActive())
-    updateActiveStyle();
-
+const HeapVector<Member<CSSStyleSheet>>
+StyleEngine::activeStyleSheetsForInspector() const {
   if (m_activeTreeScopes.isEmpty())
     return documentStyleSheetCollection().activeAuthorStyleSheets();
 
-  ActiveStyleSheetVector activeStyleSheets;
+  HeapVector<Member<CSSStyleSheet>> activeStyleSheets;
 
   activeStyleSheets.appendVector(
       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;
 }
 
 void StyleEngine::shadowRootRemovedFromDocument(ShadowRoot* shadowRoot) {
+  if (StyleResolver* styleResolver = resolver()) {
+    if (TreeScopeStyleSheetCollection* collection =
+            styleSheetCollectionFor(*shadowRoot))
+      styleResolver->removePendingAuthorStyleSheets(
+          collection->activeAuthorStyleSheets());
+  }
   m_styleSheetCollectionMap.remove(shadowRoot);
   m_activeTreeScopes.remove(shadowRoot);
   m_dirtyTreeScopes.remove(shadowRoot);
   resetAuthorStyle(*shadowRoot);
 }
 
 void StyleEngine::addTreeBoundaryCrossingScope(const TreeScope& treeScope) {
   m_treeBoundaryCrossingScopes.add(&treeScope.rootNode());
 }
 
 void StyleEngine::resetAuthorStyle(TreeScope& treeScope) {
   m_treeBoundaryCrossingScopes.remove(&treeScope.rootNode());
 
   ScopedStyleResolver* scopedResolver = treeScope.scopedStyleResolver();
   if (!scopedResolver)
     return;
 
   m_globalRuleSet.markDirty();
   if (treeScope.rootNode().isDocumentNode()) {
     scopedResolver->resetAuthorStyle();
     return;
   }
 
   treeScope.clearScopedStyleResolver();
 }
 
+void StyleEngine::finishAppendAuthorStyleSheets() {
+  m_globalRuleSet.markDirty();
+  m_globalRuleSet.update(document());
+
+  if (!document().layoutViewItem().isNull() &&
+      document().layoutViewItem().style())
+    document().layoutViewItem().style()->font().update(fontSelector());
+}
+
+void StyleEngine::appendActiveAuthorStyleSheets() {
+  DCHECK(isMaster());
+
+  m_resolver->appendAuthorStyleSheets(
+      documentStyleSheetCollection().activeAuthorStyleSheets());
+  for (TreeScope* treeScope : m_activeTreeScopes) {
+    if (TreeScopeStyleSheetCollection* collection =
+            m_styleSheetCollectionMap.get(treeScope))
+      m_resolver->appendAuthorStyleSheets(
+          collection->activeAuthorStyleSheets());
+  }
+}
+
 void StyleEngine::setRuleUsageTracker(StyleRuleUsageTracker* tracker) {
   m_tracker = tracker;
 
   if (m_resolver)
     m_resolver->setRuleUsageTracker(m_tracker);
 }
 
 RuleSet* StyleEngine::ruleSetForSheet(CSSStyleSheet& sheet) {
   if (!sheet.matchesMediaQueries(ensureMediaQueryEvaluator()))
     return nullptr;
 
   AddRuleFlags addRuleFlags = RuleHasNoSpecialState;
   if (m_document->getSecurityOrigin()->canRequest(sheet.baseURL()))
     addRuleFlags = RuleHasDocumentSecurityOrigin;
   return &sheet.contents()->ensureRuleSet(*m_mediaQueryEvaluator, addRuleFlags);
 }
 
 void StyleEngine::createResolver() {
   m_resolver = StyleResolver::create(*m_document);
+
   m_resolver->setRuleUsageTracker(m_tracker);
+
+  // A scoped style resolver for document will be created during
+  // appendActiveAuthorStyleSheets if needed.
+  appendActiveAuthorStyleSheets();
+  finishAppendAuthorStyleSheets();
 }
 
 void StyleEngine::clearResolver() {
   DCHECK(!document().inStyleRecalc());
   DCHECK(isMaster() || !m_resolver);
 
   document().clearScopedStyleResolver();
   // TODO(rune@opera.com): The clearing of all shadow tree scoped style
   // resolvers below should not be necessary. It was introduced to fix a crash
   // bug (https://crbug.com/447976) when clearResolver is called from didDetach
@@ skipping 12 matching lines @@
   m_treeBoundaryCrossingScopes.clear();
 
   if (m_resolver) {
     TRACE_EVENT1("blink", "StyleEngine::clearResolver", "frame",
                  document().frame());
     m_resolver->dispose();
     m_resolver.clear();
   }
 }
 
+void StyleEngine::clearMasterResolver() {
+  if (Document* master = this->master())
+    master->styleEngine().clearResolver();
+}
+
 void StyleEngine::didDetach() {
   clearResolver();
   m_viewportResolver = nullptr;
   m_mediaQueryEvaluator = nullptr;
 }
 
+bool StyleEngine::shouldClearResolver() const {
+  return !m_didCalculateResolver && !haveScriptBlockingStylesheetsLoaded();
+}
+
+void StyleEngine::resolverChanged(StyleResolverUpdateMode mode) {
+  if (!isMaster()) {
+    if (Document* master = this->master())
+      master->styleEngine().resolverChanged(mode);
+    return;
+  }
+
+  // Don't bother updating, since we haven't loaded all our style info yet
+  // and haven't calculated the style selector for the first time.
+  if (!document().isActive() || shouldClearResolver()) {
+    clearResolver();
+    return;
+  }
+
+  if (mode == FullStyleUpdate)
+    markAllTreeScopesDirty();
+  m_didCalculateResolver = true;
+  updateActiveStyleSheets(mode);
+}
+
 void StyleEngine::clearFontCache() {
   if (m_fontSelector)
     m_fontSelector->fontFaceCache()->clearCSSConnected();
   if (m_resolver)
     m_resolver->invalidateMatchedPropertiesCache();
 }
 
 void StyleEngine::updateGenericFontFamilySettings() {
   // FIXME: we should not update generic font family settings when
   // document is inactive.
@@ skipping 696 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(StyleEngine) {
   for (auto sheet : m_injectedAuthorStyleSheets) {
     visitor->traceWrappers(sheet);
   }
   visitor->traceWrappers(m_documentStyleSheetCollection);
 }
 
 }  // namespace blink