Revert of Collect active stylesheets and and apply asynchronously.

third_party/WebKit/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, 2010, 2012 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
@@ skipping 27 matching lines @@
 #include "core/dom/StyleSheetCandidate.h"
 
 namespace blink {
 
 DocumentStyleSheetCollection::DocumentStyleSheetCollection(TreeScope& treeScope)
     : TreeScopeStyleSheetCollection(treeScope) {
   DCHECK_EQ(treeScope.rootNode(), treeScope.rootNode().document());
 }
 
 void DocumentStyleSheetCollection::collectStyleSheetsFromCandidates(
+    StyleEngine& engine,
     DocumentStyleSheetCollector& collector) {
   for (Node* n : m_styleSheetCandidateNodes) {
     StyleSheetCandidate candidate(*n);
 
     DCHECK(!candidate.isXSL());
     if (candidate.isImport()) {
       Document* document = candidate.importedDocument();
       if (!document)
         continue;
       if (collector.hasVisited(document))
         continue;
       collector.willVisit(document);
       document->styleEngine().updateStyleSheetsInImport(collector);
       continue;
     }
 
     if (candidate.isEnabledAndLoading())
       continue;
 
     StyleSheet* sheet = candidate.sheet();
     if (!sheet)
       continue;
 
     collector.appendSheetForList(sheet);
-    if (!candidate.canBeActivated(
-            document().styleEngine().preferredStylesheetSetName()))
-      continue;
-
-    CSSStyleSheet* cssSheet = toCSSStyleSheet(sheet);
-    collector.appendActiveStyleSheet(std::make_pair(
-        cssSheet, document().styleEngine().ruleSetForSheet(*cssSheet)));
+    if (candidate.canBeActivated(engine.preferredStylesheetSetName()))
+      collector.appendActiveStyleSheet(toCSSStyleSheet(sheet));
   }
 }
 
 void DocumentStyleSheetCollection::collectStyleSheets(
+    StyleEngine& engine,
     DocumentStyleSheetCollector& collector) {
-  for (auto& sheet : document().styleEngine().injectedAuthorStyleSheets()) {
-    collector.appendActiveStyleSheet(std::make_pair(
-        sheet, document().styleEngine().ruleSetForSheet(*sheet)));
-  }
-  collectStyleSheetsFromCandidates(collector);
-  if (CSSStyleSheet* inspectorSheet =
-          document().styleEngine().inspectorStyleSheet()) {
-    collector.appendActiveStyleSheet(std::make_pair(
-        inspectorSheet,
-        document().styleEngine().ruleSetForSheet(*inspectorSheet)));
-  }
+  DCHECK_EQ(&document().styleEngine(), &engine);
+  collector.appendActiveStyleSheets(engine.injectedAuthorStyleSheets());
+  collectStyleSheetsFromCandidates(engine, collector);
+  if (engine.inspectorStyleSheet())
+    collector.appendActiveStyleSheet(engine.inspectorStyleSheet());
 }
 
-void DocumentStyleSheetCollection::updateActiveStyleSheets() {
+void DocumentStyleSheetCollection::updateActiveStyleSheets(
+    StyleEngine& engine,
+    StyleResolverUpdateMode updateMode) {
   // StyleSheetCollection is GarbageCollected<>, allocate it on the heap.
   StyleSheetCollection* collection = StyleSheetCollection::create();
   ActiveDocumentStyleSheetCollector collector(*collection);
-  collectStyleSheets(collector);
-  applyActiveStyleSheetChanges(*collection);
+  collectStyleSheets(engine, collector);
+
+  StyleSheetChange change;
+  analyzeStyleSheetChange(updateMode, collection->activeAuthorStyleSheets(),
+                          change);
+
+  if (change.styleResolverUpdateType == Reconstruct) {
+    engine.clearMasterResolver();
+    // TODO(rune@opera.com): The following depends on whether StyleRuleFontFace
+    // was modified or not.  We should only remove modified/removed @font-face
+    // rules, or @font-face rules from removed stylesheets. We currently avoid
+    // clearing the font cache when we have had an analyzed update and no
+    // @font-face rules were removed, in which case requiresFullStyleRecalc will
+    // be false.
+    if (change.requiresFullStyleRecalc)
+      engine.clearFontCache();
+  } else if (StyleResolver* styleResolver = engine.resolver()) {
+    if (change.styleResolverUpdateType != Additive) {
+      DCHECK_EQ(change.styleResolverUpdateType, Reset);
+      engine.resetAuthorStyle(treeScope());
+      engine.removeFontFaceRules(change.fontFaceRulesToRemove);
+      styleResolver->removePendingAuthorStyleSheets(m_activeAuthorStyleSheets);
+      styleResolver->lazyAppendAuthorStyleSheets(
+          0, collection->activeAuthorStyleSheets());
+    } else {
+      styleResolver->lazyAppendAuthorStyleSheets(
+          m_activeAuthorStyleSheets.size(),
+          collection->activeAuthorStyleSheets());
+    }
+  }
+  if (change.requiresFullStyleRecalc)
+    document().setNeedsStyleRecalc(
+        SubtreeStyleChange, StyleChangeReasonForTracing::create(
+                                StyleChangeReason::ActiveStylesheetsUpdate));
+
+  collection->swap(*this);
+  collection->dispose();
 }
 
 void DocumentStyleSheetCollection::collectViewportRules(
     ViewportStyleResolver& viewportResolver) {
   for (Node* node : m_styleSheetCandidateNodes) {
     StyleSheetCandidate candidate(*node);
 
     if (candidate.isImport())
       continue;
     StyleSheet* sheet = candidate.sheet();
     if (!sheet)
       continue;
     if (!candidate.canBeActivated(
             document().styleEngine().preferredStylesheetSetName()))
       continue;
     viewportResolver.collectViewportRulesFromAuthorSheet(
         *toCSSStyleSheet(sheet));
   }
 }
 
 }  // namespace blink