Current work-in-progress crbug.com/567021

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.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
@@ skipping 17 matching lines @@
 #include "core/dom/StyleEngine.h"
 
 #include "core/HTMLNames.h"
 #include "core/css/CSSDefaultStyleSheets.h"
 #include "core/css/CSSFontSelector.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/FontFaceCache.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/invalidation/InvalidationSet.h"
 #include "core/css/resolver/ScopedStyleResolver.h"
+#include "core/css/resolver/SharedStyleFinder.h"
+#include "core/css/resolver/ViewportStyleResolver.h"
 #include "core/dom/DocumentStyleSheetCollector.h"
 #include "core/dom/Element.h"
+#include "core/dom/ElementTraversal.h"
 #include "core/dom/ProcessingInstruction.h"
 #include "core/dom/ShadowTreeStyleSheetCollection.h"
 #include "core/dom/StyleChangeReason.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/html/HTMLLinkElement.h"
+#include "core/html/HTMLSlotElement.h"
 #include "core/html/imports/HTMLImportsController.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/page/Page.h"
 #include "core/svg/SVGStyleElement.h"
 #include "platform/TraceEvent.h"
 #include "platform/fonts/FontCache.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 StyleEngine::StyleEngine(Document& document)
     : m_document(&document)
     , m_isMaster(!document.importsController() || document.importsController()->master() == &document)
     , m_documentStyleSheetCollection(DocumentStyleSheetCollection::create(document))
-    // We don't need to create CSSFontSelector for imported document or
-    // HTMLTemplateElement's document, because those documents have no frame.
-    , m_fontSelector(document.frame() ? CSSFontSelector::create(&document) : nullptr)
 {
-    if (m_fontSelector)
+    if (document.frame()) {
+        // We don't need to create CSSFontSelector for imported document or
+        // HTMLTemplateElement's document, because those documents have no frame.
+        m_fontSelector = CSSFontSelector::create(&document);
         m_fontSelector->registerForInvalidationCallbacks(this);
+    }
 }
 
 StyleEngine::~StyleEngine()
 {
 }
 
 static bool isStyleElement(Node& node)
 {
     return isHTMLStyleElement(node) || isSVGStyleElement(node);
 }
@@ skipping 25 matching lines @@
         return documentStyleSheetCollection();
 
     StyleSheetCollectionMap::iterator it = m_styleSheetCollectionMap.find(&treeScope);
     if (it == m_styleSheetCollectionMap.end())
         return 0;
     return it->value.get();
 }
 
 const HeapVector<Member<StyleSheet>>& StyleEngine::styleSheetsForStyleSheetList(TreeScope& treeScope)
 {
+    // TODO(rune@opera.com): we could split styleSheets and active stylesheet
+    // update to have a lighter update while accessing the styleSheets list.
+    DCHECK(master());
+    if (master()->isActive()) {
+        if (isMaster())
+            updateActiveStyle();
+        else
+            master()->styleEngine().updateActiveStyle();
+    }
+
     if (treeScope == m_document)
         return documentStyleSheetCollection()->styleSheetsForStyleSheetList();
 
     return ensureStyleSheetCollectionFor(treeScope)->styleSheetsForStyleSheetList();
 }
 
-void StyleEngine::resetCSSFeatureFlags(const RuleFeatureSet& features)
-{
-    m_usesSiblingRules = features.usesSiblingRules();
-    m_usesFirstLineRules = features.usesFirstLineRules();
-    m_usesWindowInactiveSelector = features.usesWindowInactiveSelector();
-    m_maxDirectAdjacentSelectors = features.maxDirectAdjacentSelectors();
-}
-
 void StyleEngine::injectAuthorSheet(StyleSheetContents* authorSheet)
 {
     m_injectedAuthorStyleSheets.append(CSSStyleSheet::create(authorSheet, m_document));
     markDocumentDirty();
-    resolverChanged(AnalyzedStyleUpdate);
 }
 
 void StyleEngine::addPendingSheet(StyleEngineContext &context)
 {
     m_pendingScriptBlockingStylesheets++;
 
     context.addingPendingSheet(document());
     if (context.addedPendingSheetBeforeBody())
         m_pendingRenderBlockingStylesheets++;
 }
 
 // This method is called whenever a top-level stylesheet has finished loading.
 void StyleEngine::removePendingSheet(Node* styleSheetCandidateNode, const StyleEngineContext &context)
 {
     DCHECK(styleSheetCandidateNode);
     TreeScope* treeScope = isStyleElement(*styleSheetCandidateNode) ? &styleSheetCandidateNode->treeScope() : m_document.get();
     if (styleSheetCandidateNode->inShadowIncludingDocument())
         markTreeScopeDirty(*treeScope);
 
     if (context.addedPendingSheetBeforeBody()) {
-        DCHECK_GT(m_pendingRenderBlockingStylesheets, 0);
+        DCHECK(m_pendingRenderBlockingStylesheets);
         m_pendingRenderBlockingStylesheets--;
     }
 
     // Make sure we knew this sheet was pending, and that our count isn't out of sync.
-    DCHECK_GT(m_pendingScriptBlockingStylesheets, 0);
+    DCHECK(m_pendingScriptBlockingStylesheets);
 
     m_pendingScriptBlockingStylesheets--;
     if (m_pendingScriptBlockingStylesheets)
         return;
 
     document().didRemoveAllPendingStylesheet();
 }
 
-void StyleEngine::setNeedsActiveStyleUpdate(StyleSheet* sheet, StyleResolverUpdateMode updateMode)
+void StyleEngine::setNeedsActiveStyleUpdate(TreeScope& treeScope)
 {
-    // resolverChanged() is called for inactive non-master documents because
-    // import documents are inactive documents. resolverChanged() for imports
-    // will call resolverChanged() for the master document and update the active
-    // stylesheets including the ones from the import.
     if (!document().isActive() && isMaster())
         return;
+    markTreeScopeDirty(treeScope);
+}
 
-    if (sheet && document().isActive()) {
-        Node* node = sheet->ownerNode();
-        if (node && node->inShadowIncludingDocument()) {
-            TreeScope& treeScope = isStyleElement(*node) ? node->treeScope() : *m_document;
-            DCHECK(isStyleElement(*node) || node->treeScope() == m_document);
-            markTreeScopeDirty(treeScope);
-        }
-    }
+void StyleEngine::updateActiveStyle()
+{
+    DCHECK(document().isActive());
 
-    resolverChanged(updateMode);
+    if (!needsActiveStyleUpdate())
+        return;
+
+    updateActiveStyleSheets();
+    updateGlobalRuleSet();
+
+    DCHECK(!needsActiveStyleUpdate());
 }
 
 void StyleEngine::addStyleSheetCandidateNode(Node* node)
 {
     if (!node->inShadowIncludingDocument() || document().isDetached())
         return;
 
     TreeScope& treeScope = isStyleElement(*node) ? node->treeScope() : *m_document;
     DCHECK(isStyleElement(*node) || treeScope == m_document);
     DCHECK(!isXSLStyleSheet(*node));
@@ skipping 27 matching lines @@
 }
 
 void StyleEngine::modifiedStyleSheetCandidateNode(Node* node)
 {
     if (!node->inShadowIncludingDocument())
         return;
 
     TreeScope& treeScope = isStyleElement(*node) ? node->treeScope() : *m_document;
     DCHECK(isStyleElement(*node) || treeScope == m_document);
     markTreeScopeDirty(treeScope);
-    resolverChanged(FullStyleUpdate);
 }
 
 void StyleEngine::watchedSelectorsChanged()
 {
-    if (m_resolver) {
-        m_resolver->initWatchedSelectorRules();
-        m_resolver->resetRuleFeatures();
-    }
+    m_globalRuleSet.initWatchedSelectorsRuleSet(document());
+    m_needsGlobalRuleSetUpdate = true;
     document().setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::DeclarativeContent));
 }
 
-bool StyleEngine::shouldUpdateDocumentStyleSheetCollection(StyleResolverUpdateMode updateMode) const
+bool StyleEngine::shouldUpdateDocumentStyleSheetCollection() const
 {
-    return m_documentScopeDirty || updateMode == FullStyleUpdate;
+    return m_allTreeScopesDirty || m_documentScopeDirty;
 }
 
-bool StyleEngine::shouldUpdateShadowTreeStyleSheetCollection(StyleResolverUpdateMode updateMode) const
+bool StyleEngine::shouldUpdateShadowTreeStyleSheetCollection() const
 {
-    return !m_dirtyTreeScopes.isEmpty() || updateMode == FullStyleUpdate;
+    return m_allTreeScopesDirty || !m_dirtyTreeScopes.isEmpty();
 }
 
-void StyleEngine::clearMediaQueryRuleSetOnTreeScopeStyleSheets(UnorderedTreeScopeSet& treeScopes)
+void StyleEngine::mediaQueryAffectingValueChanged(UnorderedTreeScopeSet& treeScopes)
 {
     for (TreeScope* treeScope : treeScopes) {
         DCHECK(treeScope != m_document);
         ShadowTreeStyleSheetCollection* collection = toShadowTreeStyleSheetCollection(styleSheetCollectionFor(*treeScope));
         DCHECK(collection);
-        collection->clearMediaQueryRuleSetStyleSheets();
+        if (collection->mediaQueryAffectingValueChanged())
+            setNeedsActiveStyleUpdate(*treeScope);
     }
 }
 
-void StyleEngine::clearMediaQueryRuleSetStyleSheets()
+void StyleEngine::mediaQueryAffectingValueChanged()
 {
-    resolverChanged(FullStyleUpdate);
-    documentStyleSheetCollection()->clearMediaQueryRuleSetStyleSheets();
-    clearMediaQueryRuleSetOnTreeScopeStyleSheets(m_activeTreeScopes);
+    if (documentStyleSheetCollection()->mediaQueryAffectingValueChanged())
+        setNeedsActiveStyleUpdate(document());
+    mediaQueryAffectingValueChanged(m_activeTreeScopes);
+
+    if (!document().frame())
+        return;
+
+    if (document().wasPrinting() != document().printing() && document().frame()->pageZoomFactor() != 1)
+        document().setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleSheetChange));
 }
 
 void StyleEngine::updateStyleSheetsInImport(DocumentStyleSheetCollector& parentCollector)
 {
     DCHECK(!isMaster());
     HeapVector<Member<StyleSheet>> sheetsForList;
     ImportedDocumentStyleSheetCollector subcollector(parentCollector, sheetsForList);
-    documentStyleSheetCollection()->collectStyleSheets(*this, subcollector);
+    documentStyleSheetCollection()->collectStyleSheets(subcollector);
     documentStyleSheetCollection()->swapSheetsForSheetList(sheetsForList);
 }
 
-void StyleEngine::updateActiveStyleSheetsInShadow(StyleResolverUpdateMode updateMode, TreeScope* treeScope, UnorderedTreeScopeSet& treeScopesRemoved)
+void StyleEngine::updateActiveStyleSheetsInShadow(TreeScope* treeScope, UnorderedTreeScopeSet& treeScopesRemoved)
 {
     DCHECK_NE(treeScope, m_document);
     ShadowTreeStyleSheetCollection* collection = toShadowTreeStyleSheetCollection(styleSheetCollectionFor(*treeScope));
     DCHECK(collection);
-    collection->updateActiveStyleSheets(*this, updateMode);
+    collection->updateActiveStyleSheets();
     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(StyleResolverUpdateMode updateMode)
+void StyleEngine::updateActiveStyleSheets()
 {
+    if (!needsActiveStyleSheetUpdate())
+        return;
+
     DCHECK(isMaster());
     DCHECK(!document().inStyleRecalc());
-
-    if (!document().isActive())
-        return;
+    DCHECK(document().isActive());
 
     TRACE_EVENT0("blink,blink_style", "StyleEngine::updateActiveStyleSheets");
 
-    if (shouldUpdateDocumentStyleSheetCollection(updateMode))
-        documentStyleSheetCollection()->updateActiveStyleSheets(*this, updateMode);
+    if (shouldUpdateDocumentStyleSheetCollection()) {
+        documentStyleSheetCollection()->updateViewport();
+        documentStyleSheetCollection()->updateActiveStyleSheets();
+    }
 
-    if (shouldUpdateShadowTreeStyleSheetCollection(updateMode)) {
+    if (shouldUpdateShadowTreeStyleSheetCollection()) {
         UnorderedTreeScopeSet treeScopesRemoved;
 
-        if (updateMode == FullStyleUpdate) {
-            for (TreeScope* treeScope : m_activeTreeScopes)
-                updateActiveStyleSheetsInShadow(updateMode, treeScope, treeScopesRemoved);
-        } else {
-            for (TreeScope* treeScope : m_dirtyTreeScopes)
-                updateActiveStyleSheetsInShadow(updateMode, treeScope, treeScopesRemoved);
-        }
+        for (TreeScope* treeScope : m_dirtyTreeScopes)
+            updateActiveStyleSheetsInShadow(treeScope, treeScopesRemoved);
         for (TreeScope* treeScope : treeScopesRemoved)
             m_activeTreeScopes.remove(treeScope);
     }
 
     InspectorInstrumentation::activeStyleSheetsUpdated(m_document);
 
     m_dirtyTreeScopes.clear();
     m_documentScopeDirty = false;
+    m_allTreeScopesDirty = false;
 }
 
-const HeapVector<Member<CSSStyleSheet>> StyleEngine::activeStyleSheetsForInspector() const
+const ActiveStyleSheetVector StyleEngine::activeStyleSheetsForInspector()
 {
+    if (document().isActive())
+        updateActiveStyle();
+
     if (m_activeTreeScopes.isEmpty())
         return documentStyleSheetCollection()->activeAuthorStyleSheets();
 
-    HeapVector<Member<CSSStyleSheet>> activeStyleSheets;
+    ActiveStyleSheetVector 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::didRemoveShadowRoot(ShadowRoot* shadowRoot)
 {
     m_styleSheetCollectionMap.remove(shadowRoot);
     m_activeTreeScopes.remove(shadowRoot);
     m_dirtyTreeScopes.remove(shadowRoot);
 }
 
 void StyleEngine::shadowRootRemovedFromDocument(ShadowRoot* shadowRoot)
 {
-    if (StyleResolver* styleResolver = resolver()) {
-        styleResolver->resetAuthorStyle(*shadowRoot);
-
-        if (TreeScopeStyleSheetCollection* collection = styleSheetCollectionFor(*shadowRoot))
-            styleResolver->removePendingAuthorStyleSheets(collection->activeAuthorStyleSheets());
-    }
+    m_needsGlobalRuleSetUpdate = true;
+    shadowRoot->clearScopedStyleResolver();
     m_styleSheetCollectionMap.remove(shadowRoot);
     m_activeTreeScopes.remove(shadowRoot);
     m_dirtyTreeScopes.remove(shadowRoot);
+    m_treeBoundaryCrossingScopes.remove(&shadowRoot->rootNode());
 }
 
-void StyleEngine::appendActiveAuthorStyleSheets()
+void StyleEngine::addTreeBoundaryCrossingScope(ContainerNode& scope)
 {
-    DCHECK(isMaster());
+    m_treeBoundaryCrossingScopes.add(&scope);
+}
 
-    m_resolver->appendAuthorStyleSheets(documentStyleSheetCollection()->activeAuthorStyleSheets());
-    for (TreeScope* treeScope : m_activeTreeScopes) {
-        if (TreeScopeStyleSheetCollection* collection = m_styleSheetCollectionMap.get(treeScope))
-            m_resolver->appendAuthorStyleSheets(collection->activeAuthorStyleSheets());
-    }
-    m_resolver->finishAppendAuthorStyleSheets();
+RuleSet& StyleEngine::ensureRuleSetForSheet(CSSStyleSheet& sheet)
+{
+    if (!sheet.matchesMediaQueries(ensureMediaQueryEvaluator()))
+        return *RuleSet::emptyRuleSet();
+
+    AddRuleFlags addRuleFlags = RuleHasNoSpecialState;
+    if (m_document->getSecurityOrigin()->canRequest(sheet.baseURL()))
+        addRuleFlags = RuleHasDocumentSecurityOrigin;
+    return sheet.contents()->ensureRuleSet(*m_medium, addRuleFlags);
 }
 
 void StyleEngine::createResolver()
 {
     TRACE_EVENT1("blink", "StyleEngine::createResolver", "frame", document().frame());
     // It is a programming error to attempt to resolve style on a Document
     // which is not in a frame. Code which hits this should have checked
     // Document::isActive() before calling into code which could get here.
 
     DCHECK(document().frame());
 
     m_resolver = StyleResolver::create(*m_document);
-
-    // A scoped style resolver for document will be created during
-    // appendActiveAuthorStyleSheets if needed.
-    appendActiveAuthorStyleSheets();
 }
 
 void StyleEngine::clearResolver()
 {
     DCHECK(!document().inStyleRecalc());
     DCHECK(isMaster() || !m_resolver);
 
     document().clearScopedStyleResolver();
     // StyleEngine::shadowRootRemovedFromDocument removes not-in-document
     // treescopes from activeTreeScopes. StyleEngine::didRemoveShadowRoot
     // removes treescopes which are being destroyed from activeTreeScopes.
     // So we need to clearScopedStyleResolver for treescopes which have been
     // just removed from document. If document is destroyed before invoking
     // updateActiveStyleSheets, the treescope has a scopedStyleResolver which
     // has destroyed StyleSheetContents.
     for (TreeScope* treeScope : m_activeTreeScopes)
         treeScope->clearScopedStyleResolver();
 
     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.clear();
+    m_medium = 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;
-    }
-
-    m_didCalculateResolver = true;
-    updateActiveStyleSheets(mode);
-}
-
 void StyleEngine::clearFontCache()
 {
     if (m_fontSelector)
         m_fontSelector->fontFaceCache()->clearCSSConnected();
     if (m_resolver)
         m_resolver->invalidateMatchedPropertiesCache();
 }
 
 void StyleEngine::updateGenericFontFamilySettings()
 {
@@ skipping 15 matching lines @@
     if (!m_fontSelector)
         return;
 
     FontFaceCache* cache = m_fontSelector->fontFaceCache();
     for (unsigned i = 0; i < fontFaceRules.size(); ++i)
         cache->remove(fontFaceRules[i]);
     if (m_resolver)
         m_resolver->invalidateMatchedPropertiesCache();
 }
 
+void StyleEngine::removeFontFaceRules(const HeapVector<Member<StyleRuleFontFace>>& fontFaceRules)
+{
+    if (!m_fontSelector)
+        return;
+
+    FontFaceCache* cache = m_fontSelector->fontFaceCache();
+    for (unsigned i = 0; i < fontFaceRules.size(); ++i)
+        cache->remove(fontFaceRules[i]);
+    if (m_resolver)
+        m_resolver->invalidateMatchedPropertiesCache();
+}
+
+ViewportStyleResolver& StyleEngine::ensureViewportStyleResolver()
+{
+    if (!m_viewportResolver)
+        m_viewportResolver = ViewportStyleResolver::create(m_document);
+    return *m_viewportResolver.get();
+}
+
 void StyleEngine::markTreeScopeDirty(TreeScope& scope)
 {
     if (scope == m_document) {
         markDocumentDirty();
         return;
     }
 
     DCHECK(m_styleSheetCollectionMap.contains(&scope));
     m_dirtyTreeScopes.add(&scope);
+    document().scheduleLayoutTreeUpdateIfNeeded();
 }
 
 void StyleEngine::markDocumentDirty()
 {
     m_documentScopeDirty = true;
     if (document().importLoader())
         document().importsController()->master()->styleEngine().markDocumentDirty();
+    else
+        document().scheduleLayoutTreeUpdateIfNeeded();
 }
 
 CSSStyleSheet* StyleEngine::createSheet(Element* e, const String& text, TextPosition startPosition, StyleEngineContext &context)
 {
     CSSStyleSheet* styleSheet = nullptr;
 
-    e->document().styleEngine().addPendingSheet(context);
+    addPendingSheet(context);
 
     AtomicString textContent(text);
 
     HeapHashMap<AtomicString, Member<StyleSheetContents>>::AddResult result = m_textToSheetCache.add(textContent, nullptr);
     if (result.isNewEntry || !result.storedValue->value) {
-        styleSheet = StyleEngine::parseSheet(e, text, startPosition);
+        styleSheet = parseSheet(e, text, startPosition);
         if (result.isNewEntry && styleSheet->contents()->isCacheableForStyleElement()) {
             result.storedValue->value = styleSheet->contents();
             m_sheetToTextCache.add(styleSheet->contents(), textContent);
         }
     } else {
         StyleSheetContents* contents = result.storedValue->value;
         DCHECK(contents);
         DCHECK(contents->isCacheableForStyleElement());
-        DCHECK_EQ(contents->singleOwnerDocument(), e->document());
+        DCHECK_EQ(contents->singleOwnerDocument(), document());
         styleSheet = CSSStyleSheet::createInline(contents, e, startPosition);
     }
 
     DCHECK(styleSheet);
     styleSheet->setTitle(e->title());
+    if (!e->isInShadowTree())
+        setPreferredStylesheetSetNameIfNotSet(e->title());
     return styleSheet;
 }
 
 CSSStyleSheet* StyleEngine::parseSheet(Element* e, const String& text, TextPosition startPosition)
 {
     CSSStyleSheet* styleSheet = nullptr;
-    styleSheet = CSSStyleSheet::createInline(e, KURL(), startPosition, e->document().characterSet());
+    styleSheet = CSSStyleSheet::createInline(e, KURL(), startPosition, document().characterSet());
     styleSheet->contents()->parseStringAtPosition(text, startPosition);
     return styleSheet;
 }
 
 void StyleEngine::removeSheet(StyleSheetContents* contents)
 {
     HeapHashMap<Member<StyleSheetContents>, AtomicString>::iterator it = m_sheetToTextCache.find(contents);
     if (it == m_sheetToTextCache.end())
         return;
 
     m_textToSheetCache.remove(it->value);
     m_sheetToTextCache.remove(contents);
 }
 
+bool StyleEngine::hasRulesForId(const AtomicString& id) const
+{
+    return m_globalRuleSet.m_features.hasSelectorForId(id);
+}
+
+void StyleEngine::updateGlobalRuleSet()
+{
+    if (!m_needsGlobalRuleSetUpdate)
+        return;
+
+    m_globalRuleSet.update(document());
+    m_needsGlobalRuleSetUpdate = false;
+}
+
 void StyleEngine::collectScopedStyleFeaturesTo(RuleFeatureSet& features) const
 {
     HeapHashSet<Member<const StyleSheetContents>> visitedSharedStyleSheetContents;
     if (document().scopedStyleResolver())
         document().scopedStyleResolver()->collectFeaturesTo(features, visitedSharedStyleSheetContents);
     for (TreeScope* treeScope : m_activeTreeScopes) {
         // When creating StyleResolver, dirty treescopes might not be processed.
         // So some active treescopes might not have a scoped style resolver.
         // In this case, we should skip collectFeatures for the treescopes without
         // scoped style resolvers. When invoking updateActiveStyleSheets,
@@ skipping 39 matching lines @@
         return true;
     return element.parentNode()->getStyleChangeType() >= SubtreeStyleChange;
 }
 
 void StyleEngine::classChangedForElement(const SpaceSplitString& changedClasses, Element& element)
 {
     if (shouldSkipInvalidationFor(element))
         return;
     InvalidationLists invalidationLists;
     unsigned changedSize = changedClasses.size();
-    RuleFeatureSet& ruleFeatureSet = ensureResolver().ensureUpdatedRuleFeatureSet();
+    const RuleFeatureSet& ruleFeatures = ruleFeatureSet();
     for (unsigned i = 0; i < changedSize; ++i)
-        ruleFeatureSet.collectInvalidationSetsForClass(invalidationLists, element, changedClasses[i]);
+        ruleFeatures.collectInvalidationSetsForClass(invalidationLists, element, changedClasses[i]);
     m_styleInvalidator.scheduleInvalidationSetsForElement(invalidationLists, element);
 }
 
 void StyleEngine::classChangedForElement(const SpaceSplitString& oldClasses, const SpaceSplitString& newClasses, Element& element)
 {
     if (shouldSkipInvalidationFor(element))
         return;
 
     if (!oldClasses.size()) {
         classChangedForElement(newClasses, element);
         return;
     }
 
     // Class vectors tend to be very short. This is faster than using a hash table.
     BitVector remainingClassBits;
     remainingClassBits.ensureSize(oldClasses.size());
 
     InvalidationLists invalidationLists;
-    RuleFeatureSet& ruleFeatureSet = ensureResolver().ensureUpdatedRuleFeatureSet();
+    const RuleFeatureSet& ruleFeatures = ruleFeatureSet();
 
     for (unsigned i = 0; i < newClasses.size(); ++i) {
         bool found = false;
         for (unsigned j = 0; j < oldClasses.size(); ++j) {
             if (newClasses[i] == oldClasses[j]) {
                 // Mark each class that is still in the newClasses so we can skip doing
                 // an n^2 search below when looking for removals. We can't break from
                 // this loop early since a class can appear more than once.
                 remainingClassBits.quickSet(j);
                 found = true;
             }
         }
         // Class was added.
         if (!found)
-            ruleFeatureSet.collectInvalidationSetsForClass(invalidationLists, element, newClasses[i]);
+            ruleFeatures.collectInvalidationSetsForClass(invalidationLists, element, newClasses[i]);
     }
 
     for (unsigned i = 0; i < oldClasses.size(); ++i) {
         if (remainingClassBits.quickGet(i))
             continue;
         // Class was removed.
-        ruleFeatureSet.collectInvalidationSetsForClass(invalidationLists, element, oldClasses[i]);
+        ruleFeatures.collectInvalidationSetsForClass(invalidationLists, element, oldClasses[i]);
     }
 
     m_styleInvalidator.scheduleInvalidationSetsForElement(invalidationLists, element);
 }
 
 void StyleEngine::attributeChangedForElement(const QualifiedName& attributeName, Element& element)
 {
     if (shouldSkipInvalidationFor(element))
         return;
 
     InvalidationLists invalidationLists;
-    ensureResolver().ensureUpdatedRuleFeatureSet().collectInvalidationSetsForAttribute(invalidationLists, element, attributeName);
+    ruleFeatureSet().collectInvalidationSetsForAttribute(invalidationLists, element, attributeName);
     m_styleInvalidator.scheduleInvalidationSetsForElement(invalidationLists, element);
 }
 
 void StyleEngine::idChangedForElement(const AtomicString& oldId, const AtomicString& newId, Element& element)
 {
     if (shouldSkipInvalidationFor(element))
         return;
 
     InvalidationLists invalidationLists;
-    RuleFeatureSet& ruleFeatureSet = ensureResolver().ensureUpdatedRuleFeatureSet();
+    const RuleFeatureSet& ruleFeatures = ruleFeatureSet();
     if (!oldId.isEmpty())
-        ruleFeatureSet.collectInvalidationSetsForId(invalidationLists, element, oldId);
+        ruleFeatures.collectInvalidationSetsForId(invalidationLists, element, oldId);
     if (!newId.isEmpty())
-        ruleFeatureSet.collectInvalidationSetsForId(invalidationLists, element, newId);
+        ruleFeatures.collectInvalidationSetsForId(invalidationLists, element, newId);
     m_styleInvalidator.scheduleInvalidationSetsForElement(invalidationLists, element);
 }
 
 void StyleEngine::pseudoStateChangedForElement(CSSSelector::PseudoType pseudoType, Element& element)
 {
     if (shouldSkipInvalidationFor(element))
         return;
 
     InvalidationLists invalidationLists;
-    ensureResolver().ensureUpdatedRuleFeatureSet().collectInvalidationSetsForPseudoClass(invalidationLists, element, pseudoType);
+    ruleFeatureSet().collectInvalidationSetsForPseudoClass(invalidationLists, element, pseudoType);
     m_styleInvalidator.scheduleInvalidationSetsForElement(invalidationLists, element);
 }
 
 void StyleEngine::setStatsEnabled(bool enabled)
 {
     if (!enabled) {
         m_styleResolverStats = nullptr;
         return;
     }
     if (!m_styleResolverStats)
         m_styleResolverStats = StyleResolverStats::create();
     else
         m_styleResolverStats->reset();
 }
 
+void StyleEngine::scheduleRuleSetInvalidationsForElement(Element& element, const HeapVector<Member<RuleSet>>& ruleSets)
+{
+    AtomicString id;
+    const SpaceSplitString* classNames = nullptr;
+    bool typeSelectorMatch = false;
+    const AtomicString& shadowPseudoId = element.shadowPseudoId();
+    bool customPseudoMatch = shadowPseudoId.isEmpty();
+
+    if (element.hasID())
+        id = element.idForStyleResolution();
+    if (element.hasClass())
+        classNames = &element.classNames();
+
+    InvalidationLists invalidationLists;
+    for (const auto& ruleSet : ruleSets) {
+
+        if (!id.isNull())
+            ruleSet->features().collectInvalidationSetsForId(invalidationLists, element, id);
+
+        if (classNames) {
+            unsigned classNameCount = classNames->size();
+            for (size_t i = 0; i < classNameCount; i++)
+                ruleSet->features().collectInvalidationSetsForClass(invalidationLists, element, (*classNames)[i]);
+        }
+
+        for (const Attribute& attribute : element.attributes())
+            ruleSet->features().collectInvalidationSetsForAttribute(invalidationLists, element, attribute.name());
+
+        if (element.needsStyleRecalc())
+            continue;
+
+        if (!typeSelectorMatch && ruleSet->tagRules(element.localNameForSelectorMatching())) {
+            typeSelectorMatch = true;
+            element.setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleSheetChange));
+        }
+
+        if (!customPseudoMatch && ruleSet->shadowPseudoElementRules(shadowPseudoId)) {
+            customPseudoMatch = true;
+            element.setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleSheetChange));
+        }
+    }
+    m_styleInvalidator.scheduleInvalidationSetsForElement(invalidationLists, element);
+}
+
+void StyleEngine::scheduleInvalidationsForRuleSets(TreeScope& treeScope, const HeapVector<Member<RuleSet>>& ruleSets)
+{
+    if (treeScope.rootNode().isShadowRoot()) {
+        Element& host = toShadowRoot(treeScope.rootNode()).host();
+        scheduleRuleSetInvalidationsForElement(host, ruleSets);
+        if (host.getStyleChangeType() >= SubtreeStyleChange)
+            return;
+    }
+
+    Node* stayWithin = &treeScope.rootNode();
+    Element* element = ElementTraversal::firstChild(*stayWithin);
+    while (element) {
+        scheduleRuleSetInvalidationsForElement(*element, ruleSets);
+        if (isHTMLSlotElement(element)) {
+            for (auto& node : toHTMLSlotElement(element)->getDistributedNodes()) {
+                if (node->isElementNode())
+                    scheduleRuleSetInvalidationsForElement(*toElement(node), ruleSets);
+            }
+        }
+        if (element->getStyleChangeType() < SubtreeStyleChange)
+            element = ElementTraversal::next(*element, stayWithin);
+        else
+            element = ElementTraversal::nextSkippingChildren(*element, stayWithin);
+    }
+}
+
 void StyleEngine::setPreferredStylesheetSetNameIfNotSet(const String& name)
 {
     if (!m_preferredStylesheetSetName.isEmpty())
         return;
     m_preferredStylesheetSetName = name;
     // TODO(rune@opera.com): Setting the selected set here is wrong if the set
     // has been previously set by through Document.selectedStylesheetSet. Our
     // current implementation ignores the effect of Document.selectedStylesheetSet
     // and either only collects persistent style, or additionally preferred
     // style when present. We are currently not marking the document scope dirty
     // because preferred style is updated during active stylesheet update which
     // would make this method re-entrant. Will need to change for async update.
     m_selectedStylesheetSetName = name;
 }
 
 void StyleEngine::setSelectedStylesheetSetName(const String& name)
 {
     m_selectedStylesheetSetName = name;
     // TODO(rune@opera.com): Setting Document.selectedStylesheetSet currently
     // has no other effect than the ability to read back the set value using
     // the same api. If it did have an effect, we should have marked the
     // document scope dirty and triggered an update of the active stylesheets
     // from here.
 }
 
 void StyleEngine::setHttpDefaultStyle(const String& content)
 {
     setPreferredStylesheetSetNameIfNotSet(content);
     markDocumentDirty();
-    resolverChanged(FullStyleUpdate);
 }
 
-void StyleEngine::ensureFullscreenUAStyle()
+void StyleEngine::ensureUAStyleForFullscreen()
 {
-    CSSDefaultStyleSheets::instance().ensureDefaultStyleSheetForFullscreen();
-    if (!m_resolver)
-        return;
-    if (!m_resolver->hasFullscreenUAStyle())
-        m_resolver->resetRuleFeatures();
+    if (CSSDefaultStyleSheets::instance().ensureDefaultStyleSheetForFullscreen()) {
+        m_needsGlobalRuleSetUpdate = true;
+        updateGlobalRuleSet();
+    }
+}
+
+void StyleEngine::ensureUAStyleForElement(const Element& element)
+{
+    if (CSSDefaultStyleSheets::instance().ensureDefaultStyleSheetsForElement(element)) {
+        m_needsGlobalRuleSetUpdate = true;
+        updateGlobalRuleSet();
+    }
+}
+
+PassRefPtr<ComputedStyle> StyleEngine::findSharedStyle(const ElementResolveContext& elementResolveContext)
+{
+    return SharedStyleFinder(elementResolveContext,
+        m_globalRuleSet.m_features,
+        m_globalRuleSet.m_siblingRuleSet.get(),
+        m_globalRuleSet.m_uncommonAttributeRuleSet.get(),
+        *m_resolver).findSharedStyle();
+}
+
+MediaQueryEvaluator& StyleEngine::ensureMediaQueryEvaluator()
+{
+    if (!m_medium) {
+        if (document().frame())
+            m_medium = new MediaQueryEvaluator(document().frame());
+        else
+            m_medium = new MediaQueryEvaluator("all");
+    }
+    return *m_medium;
+}
+
+bool StyleEngine::mediaQueryAffectedByViewportChange()
+{
+    const MediaQueryEvaluator& evaluator = ensureMediaQueryEvaluator();
+    const auto& results = m_globalRuleSet.m_features.viewportDependentMediaQueryResults;
+    for (unsigned i = 0; i < results.size(); ++i) {
+        if (evaluator.eval(results[i]->expression()) != results[i]->result())
+            return true;
+    }
+    return false;
+}
+
+bool StyleEngine::mediaQueryAffectedByDeviceChange()
+{
+    const MediaQueryEvaluator& evaluator = ensureMediaQueryEvaluator();
+    const auto& results = m_globalRuleSet.m_features.deviceDependentMediaQueryResults;
+    for (unsigned i = 0; i < results.size(); ++i) {
+        if (evaluator.eval(results[i]->expression()) != results[i]->result())
+            return true;
+    }
+    return false;
 }
 
 DEFINE_TRACE(StyleEngine)
 {
     visitor->trace(m_document);
     visitor->trace(m_injectedAuthorStyleSheets);
     visitor->trace(m_documentStyleSheetCollection);
     visitor->trace(m_styleSheetCollectionMap);
     visitor->trace(m_resolver);
+    visitor->trace(m_viewportResolver);
+    visitor->trace(m_medium);
     visitor->trace(m_styleInvalidator);
     visitor->trace(m_dirtyTreeScopes);
     visitor->trace(m_activeTreeScopes);
+    visitor->trace(m_treeBoundaryCrossingScopes);
+    visitor->trace(m_globalRuleSet);
     visitor->trace(m_fontSelector);
     visitor->trace(m_textToSheetCache);
     visitor->trace(m_sheetToTextCache);
     CSSFontSelectorClient::trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(StyleEngine)
 {
     for (auto sheet : m_injectedAuthorStyleSheets) {
         visitor->traceWrappers(sheet);
     }
     visitor->traceWrappers(m_documentStyleSheetCollection);
 }
 
 } // namespace blink