Revert of Collect active stylesheets and and apply asynchronously.

third_party/WebKit/Source/core/dom/StyleEngine.h

 /*
  * 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 81 matching lines @@
 
   const HeapVector<TraceWrapperMember<StyleSheet>>&
   styleSheetsForStyleSheetList(TreeScope&);
 
   const HeapVector<TraceWrapperMember<CSSStyleSheet>>&
   injectedAuthorStyleSheets() const {
     return m_injectedAuthorStyleSheets;
   }
   CSSStyleSheet* inspectorStyleSheet() const { return m_inspectorStyleSheet; }
 
-  const ActiveStyleSheetVector activeStyleSheetsForInspector();
+  const HeapVector<Member<CSSStyleSheet>> activeStyleSheetsForInspector() const;
 
   bool needsActiveStyleUpdate() const;
   void setNeedsActiveStyleUpdate(TreeScope&);
   void addStyleSheetCandidateNode(Node&);
   void removeStyleSheetCandidateNode(Node&, ContainerNode& insertionPoint);
   void modifiedStyleSheetCandidateNode(Node&);
   void mediaQueriesChangedInScope(TreeScope&);
   void watchedSelectorsChanged();
   void initialViewportChanged();
   void viewportRulesChanged();
   void htmlImportAddedOrRemoved();
 
   void injectAuthorSheet(StyleSheetContents* authorSheet);
   CSSStyleSheet& ensureInspectorStyleSheet();
   RuleSet* watchedSelectorsRuleSet() {
     return m_globalRuleSet.watchedSelectorsRuleSet();
   }
 
   RuleSet* ruleSetForSheet(CSSStyleSheet&);
   void mediaQueryAffectingValueChanged();
   void updateStyleSheetsInImport(DocumentStyleSheetCollector& parentCollector);
+  void updateActiveStyleSheets(StyleResolverUpdateMode);
   void updateActiveStyle();
   void markAllTreeScopesDirty() { m_allTreeScopesDirty = true; }
 
   enum ActiveSheetsUpdate { DontUpdateActiveSheets, UpdateActiveSheets };
   String preferredStylesheetSetName() const {
     return m_preferredStylesheetSetName;
   }
   String selectedStylesheetSetName() const {
     return m_selectedStylesheetSetName;
   }
@@ skipping 41 matching lines @@
     return m_treeBoundaryCrossingScopes;
   }
   void resetAuthorStyle(TreeScope&);
 
   StyleResolver* resolver() const { return m_resolver; }
 
   void setRuleUsageTracker(StyleRuleUsageTracker*);
 
   StyleResolver& ensureResolver() {
     updateActiveStyle();
-    if (!m_resolver)
+    if (!m_resolver) {
       createResolver();
+    } else if (m_resolver->hasPendingAuthorStyleSheets()) {
+      m_resolver->appendPendingAuthorStyleSheets();
+      finishAppendAuthorStyleSheets();
+    } else if (m_globalRuleSet.isDirty()) {
+      m_globalRuleSet.update(document());
+    }
     return *m_resolver;
   }
 
   bool hasResolver() const { return m_resolver; }
   void clearResolver();
+  void clearMasterResolver();
 
   StyleInvalidator& styleInvalidator() { return m_styleInvalidator; }
   bool mediaQueryAffectedByViewportChange();
   bool mediaQueryAffectedByDeviceChange();
   bool hasViewportDependentMediaQueries() const {
     return !m_globalRuleSet.ruleFeatureSet()
                 .viewportDependentMediaQueryResults()
                 .isEmpty();
   }
 
   CSSFontSelector* fontSelector() { return m_fontSelector; }
   void setFontSelector(CSSFontSelector*);
 
   void removeFontFaceRules(const HeapVector<Member<const StyleRuleFontFace>>&);
   void clearFontCache();
   // updateGenericFontFamilySettings is used from WebSettingsImpl.
   void updateGenericFontFamilySettings();
 
   void didDetach();
-  void resolverChanged(StyleResolverUpdateMode) {}
+  bool shouldClearResolver() const;
+  void resolverChanged(StyleResolverUpdateMode);
 
   CSSStyleSheet* createSheet(Element&,
                              const String& text,
                              TextPosition startPosition,
                              StyleEngineContext&);
 
   void collectScopedStyleFeaturesTo(RuleFeatureSet&) const;
   void ensureUAStyleForFullscreen();
   void ensureUAStyleForElement(const Element&);
 
@@ skipping 60 matching lines @@
   Document& document() const { return *m_document; }
 
   typedef HeapHashSet<Member<TreeScope>> UnorderedTreeScopeSet;
 
   void mediaQueryAffectingValueChanged(UnorderedTreeScopeSet&);
   const RuleFeatureSet& ruleFeatureSet() const {
     return m_globalRuleSet.ruleFeatureSet();
   }
 
   void createResolver();
+  void appendActiveAuthorStyleSheets();
+  void finishAppendAuthorStyleSheets();
 
   CSSStyleSheet* parseSheet(Element&,
                             const String& text,
                             TextPosition startPosition);
 
   const DocumentStyleSheetCollection& documentStyleSheetCollection() const {
     DCHECK(m_documentStyleSheetCollection);
     return *m_documentStyleSheetCollection;
   }
 
   DocumentStyleSheetCollection& documentStyleSheetCollection() {
     DCHECK(m_documentStyleSheetCollection);
     return *m_documentStyleSheetCollection;
   }
 
   void updateActiveStyleSheetsInShadow(
+      StyleResolverUpdateMode,
       TreeScope*,
       UnorderedTreeScopeSet& treeScopesRemoved);
 
   bool shouldSkipInvalidationFor(const Element&) const;
   void scheduleRuleSetInvalidationsForElement(
       Element&,
       const HeapHashSet<Member<RuleSet>>&);
   void invalidateSlottedElements(HTMLSlotElement&);
 
   void updateViewport();
@@ skipping 11 matching lines @@
   int m_pendingRenderBlockingStylesheets = 0;
 
   HeapVector<TraceWrapperMember<CSSStyleSheet>> m_injectedAuthorStyleSheets;
   Member<CSSStyleSheet> m_inspectorStyleSheet;
 
   TraceWrapperMember<DocumentStyleSheetCollection>
       m_documentStyleSheetCollection;
 
   Member<StyleRuleUsageTracker> m_tracker;
 
-  using StyleSheetCollectionMap =
-      HeapHashMap<WeakMember<TreeScope>,
-                  Member<ShadowTreeStyleSheetCollection>>;
+  typedef HeapHashMap<WeakMember<TreeScope>,
+                      Member<ShadowTreeStyleSheetCollection>>
+      StyleSheetCollectionMap;
   StyleSheetCollectionMap m_styleSheetCollectionMap;
 
   bool m_documentScopeDirty = true;
   bool m_allTreeScopesDirty = false;
   UnorderedTreeScopeSet m_dirtyTreeScopes;
   UnorderedTreeScopeSet m_activeTreeScopes;
   DocumentOrderedList m_treeBoundaryCrossingScopes;
 
   String m_preferredStylesheetSetName;
   String m_selectedStylesheetSetName;
 
   CSSGlobalRuleSet m_globalRuleSet;
 
   bool m_usesRemUnits = false;
   bool m_ignorePendingStylesheets = false;
+  bool m_didCalculateResolver = false;
 
   Member<StyleResolver> m_resolver;
   Member<ViewportStyleResolver> m_viewportResolver;
   Member<MediaQueryEvaluator> m_mediaQueryEvaluator;
   StyleInvalidator m_styleInvalidator;
 
   Member<CSSFontSelector> m_fontSelector;
 
   HeapHashMap<AtomicString, WeakMember<StyleSheetContents>> m_textToSheetCache;
   HeapHashMap<WeakMember<StyleSheetContents>, AtomicString> m_sheetToTextCache;
 
   std::unique_ptr<StyleResolverStats> m_styleResolverStats;
   unsigned m_styleForElementCount = 0;
 
   friend class StyleEngineTest;
 };
 
 }  // namespace blink
 
 #endif