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

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
   5  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
   6  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All rights reserved.
   7  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
   8  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
   9  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  10  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Library General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Library General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Library General Public License
  23  * along with this library; see the file COPYING.LIB.  If not, write to
  24  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  25  * Boston, MA 02110-1301, USA.
  26  */
  27
  28 #include "config.h"
  29 #include "core/dom/StyleEngine.h"
  30
  31 #include "core/HTMLNames.h"
  32 #include "core/css/CSSFontSelector.h"
  33 #include "core/css/CSSStyleSheet.h"
  34 #include "core/css/FontFaceCache.h"
  35 #include "core/css/StyleSheetContents.h"
  36 #include "core/css/resolver/ScopedStyleResolver.h"
  37 #include "core/dom/DocumentStyleSheetCollector.h"
  38 #include "core/dom/Element.h"
  39 #include "core/dom/ProcessingInstruction.h"
  40 #include "core/dom/ShadowTreeStyleSheetCollection.h"
  41 #include "core/dom/shadow/ShadowRoot.h"
  42 #include "core/frame/Settings.h"
  43 #include "core/html/HTMLIFrameElement.h"
  44 #include "core/html/HTMLLinkElement.h"
  45 #include "core/html/imports/HTMLImportsController.h"
  46 #include "core/inspector/InspectorInstrumentation.h"
  47 #include "core/page/Page.h"
  48 #include "core/svg/SVGStyleElement.h"
  49 #include "platform/TraceEvent.h"
  50
  51 namespace blink {
  52
  53 using namespace HTMLNames;
  54
  55 StyleEngine::StyleEngine(Document& document)
  56     : m_document(&document)
  57     , m_isMaster(!document.importsController() || document.importsController()->master() == &document)
  58     , m_pendingStylesheets(0)
  59     , m_documentStyleSheetCollection(DocumentStyleSheetCollection::create(document))
  60     , m_documentScopeDirty(true)
  61     , m_usesSiblingRules(false)
  62     , m_usesFirstLineRules(false)
  63     , m_usesWindowInactiveSelector(false)
  64     , m_usesRemUnits(false)
  65     , m_maxDirectAdjacentSelectors(0)
  66     , m_ignorePendingStylesheets(false)
  67     , m_didCalculateResolver(false)
  68     // We don't need to create CSSFontSelector for imported document or
  69     // HTMLTemplateElement's document, because those documents have no frame.
  70     , m_fontSelector(document.frame() ? CSSFontSelector::create(&document) : nullptr)
  71 {
  72     if (m_fontSelector)
  73         m_fontSelector->registerForInvalidationCallbacks(this);
  74 }
  75
  76 StyleEngine::~StyleEngine()
  77 {
  78 }
  79
  80 static bool isStyleElement(Node& node)
  81 {
  82     return isHTMLStyleElement(node) || isSVGStyleElement(node);
  83 }
  84
  85 #if !ENABLE(OILPAN)
  86 void StyleEngine::detachFromDocument()
  87 {
  88     // Cleanup is performed eagerly when the StyleEngine is removed from the
  89     // document. The StyleEngine is unreachable after this, since only the
  90     // document has a reference to it.
  91     for (unsigned i = 0; i < m_authorStyleSheets.size(); ++i)
  92         m_authorStyleSheets[i]->clearOwnerNode();
  93
  94     if (m_fontSelector) {
  95         m_fontSelector->clearDocument();
  96         m_fontSelector->unregisterForInvalidationCallbacks(this);
  97     }
  98
  99     // Decrement reference counts for things we could be keeping alive.
 100     m_fontSelector.clear();
 101     m_resolver.clear();
 102     m_styleSheetCollectionMap.clear();
 103     m_activeTreeScopes.clear();
 104 }
 105 #endif
 106
 107 inline Document* StyleEngine::master()
 108 {
 109     if (isMaster())
 110         return m_document;
 111     HTMLImportsController* import = document().importsController();
 112     if (!import) // Document::import() can return null while executing its destructor.
 113         return 0;
 114     return import->master();
 115 }
 116
 117 TreeScopeStyleSheetCollection* StyleEngine::ensureStyleSheetCollectionFor(TreeScope& treeScope)
 118 {
 119     if (treeScope == m_document)
 120         return documentStyleSheetCollection();
 121
 122     StyleSheetCollectionMap::AddResult result = m_styleSheetCollectionMap.add(&treeScope, nullptr);
 123     if (result.isNewEntry)
 124         result.storedValue->value = adoptPtrWillBeNoop(new ShadowTreeStyleSheetCollection(toShadowRoot(treeScope)));
 125     return result.storedValue->value.get();
 126 }
 127
 128 TreeScopeStyleSheetCollection* StyleEngine::styleSheetCollectionFor(TreeScope& treeScope)
 129 {
 130     if (treeScope == m_document)
 131         return documentStyleSheetCollection();
 132
 133     StyleSheetCollectionMap::iterator it = m_styleSheetCollectionMap.find(&treeScope);
 134     if (it == m_styleSheetCollectionMap.end())
 135         return 0;
 136     return it->value.get();
 137 }
 138
 139 const WillBeHeapVector<RefPtrWillBeMember<StyleSheet>>& StyleEngine::styleSheetsForStyleSheetList(TreeScope& treeScope)
 140 {
 141     if (treeScope == m_document)
 142         return documentStyleSheetCollection()->styleSheetsForStyleSheetList();
 143
 144     return ensureStyleSheetCollectionFor(treeScope)->styleSheetsForStyleSheetList();
 145 }
 146
 147 const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet>>& StyleEngine::activeAuthorStyleSheets() const
 148 {
 149     return documentStyleSheetCollection()->activeAuthorStyleSheets();
 150 }
 151
 152 void StyleEngine::combineCSSFeatureFlags(const RuleFeatureSet& features)
 153 {
 154     // Delay resetting the flags until after next style recalc since unapplying the style may not work without these set (this is true at least with before/after).
 155     m_usesSiblingRules = m_usesSiblingRules || features.usesSiblingRules();
 156     m_usesFirstLineRules = m_usesFirstLineRules || features.usesFirstLineRules();
 157     m_usesWindowInactiveSelector = m_usesWindowInactiveSelector || features.usesWindowInactiveSelector();
 158     m_maxDirectAdjacentSelectors = max(m_maxDirectAdjacentSelectors, features.maxDirectAdjacentSelectors());
 159 }
 160
 161 void StyleEngine::resetCSSFeatureFlags(const RuleFeatureSet& features)
 162 {
 163     m_usesSiblingRules = features.usesSiblingRules();
 164     m_usesFirstLineRules = features.usesFirstLineRules();
 165     m_usesWindowInactiveSelector = features.usesWindowInactiveSelector();
 166     m_maxDirectAdjacentSelectors = features.maxDirectAdjacentSelectors();
 167 }
 168
 169 void StyleEngine::addAuthorSheet(PassRefPtrWillBeRawPtr<StyleSheetContents> authorSheet)
 170 {
 171     m_authorStyleSheets.append(CSSStyleSheet::create(authorSheet, m_document));
 172     document().addedStyleSheet(m_authorStyleSheets.last().get());
 173     markDocumentDirty();
 174 }
 175
 176 void StyleEngine::addPendingSheet()
 177 {
 178     m_pendingStylesheets++;
 179 }
 180
 181 // This method is called whenever a top-level stylesheet has finished loading.
 182 void StyleEngine::removePendingSheet(Node* styleSheetCandidateNode)
 183 {
 184     ASSERT(styleSheetCandidateNode);
 185     TreeScope* treeScope = isStyleElement(*styleSheetCandidateNode) ? &styleSheetCandidateNode->treeScope() : m_document.get();
 186     if (styleSheetCandidateNode->inDocument())
 187         markTreeScopeDirty(*treeScope);
 188
 189     // Make sure we knew this sheet was pending, and that our count isn't out of sync.
 190     ASSERT(m_pendingStylesheets > 0);
 191
 192     m_pendingStylesheets--;
 193     if (m_pendingStylesheets)
 194         return;
 195
 196     // FIXME: We can't call addedStyleSheet or removedStyleSheet here because we don't know
 197     // what's new. We should track that to tell the style system what changed.
 198     document().didRemoveAllPendingStylesheet();
 199 }
 200
 201 void StyleEngine::modifiedStyleSheet(StyleSheet* sheet)
 202 {
 203     if (!sheet)
 204         return;
 205
 206     Node* node = sheet->ownerNode();
 207     if (!node || !node->inDocument())
 208         return;
 209
 210     TreeScope& treeScope = isStyleElement(*node) ? node->treeScope() : *m_document;
 211     ASSERT(isStyleElement(*node) || treeScope == m_document);
 212
 213     markTreeScopeDirty(treeScope);
 214 }
 215
 216 void StyleEngine::addStyleSheetCandidateNode(Node* node, bool createdByParser)
 217 {
 218     if (!node->inDocument() || document().isDetached())
 219         return;
 220
 221     TreeScope& treeScope = isStyleElement(*node) ? node->treeScope() : *m_document;
 222     ASSERT(isStyleElement(*node) || treeScope == m_document);
 223     ASSERT(!isXSLStyleSheet(*node));
 224     TreeScopeStyleSheetCollection* collection = ensureStyleSheetCollectionFor(treeScope);
 225     ASSERT(collection);
 226     collection->addStyleSheetCandidateNode(node, createdByParser);
 227
 228     markTreeScopeDirty(treeScope);
 229     if (treeScope != m_document)
 230         m_activeTreeScopes.add(&treeScope);
 231 }
 232
 233 void StyleEngine::removeStyleSheetCandidateNode(Node* node)
 234 {
 235     removeStyleSheetCandidateNode(node, *m_document);
 236 }
 237
 238 void StyleEngine::removeStyleSheetCandidateNode(Node* node, TreeScope& treeScope)
 239 {
 240     ASSERT(isStyleElement(*node) || treeScope == m_document);
 241     ASSERT(!isXSLStyleSheet(*node));
 242
 243     TreeScopeStyleSheetCollection* collection = styleSheetCollectionFor(treeScope);
 244     // After detaching document, collection could be null. In the case,
 245     // we should not update anything. Instead, just return.
 246     if (!collection)
 247         return;
 248     collection->removeStyleSheetCandidateNode(node);
 249
 250     markTreeScopeDirty(treeScope);
 251 }
 252
 253 void StyleEngine::modifiedStyleSheetCandidateNode(Node* node)
 254 {
 255     if (!node->inDocument())
 256         return;
 257
 258     TreeScope& treeScope = isStyleElement(*node) ? node->treeScope() : *m_document;
 259     ASSERT(isStyleElement(*node) || treeScope == m_document);
 260     markTreeScopeDirty(treeScope);
 261 }
 262
 263 bool StyleEngine::shouldUpdateDocumentStyleSheetCollection(StyleResolverUpdateMode updateMode) const
 264 {
 265     return m_documentScopeDirty || updateMode == FullStyleUpdate;
 266 }
 267
 268 bool StyleEngine::shouldUpdateShadowTreeStyleSheetCollection(StyleResolverUpdateMode updateMode) const
 269 {
 270     return !m_dirtyTreeScopes.isEmpty() || updateMode == FullStyleUpdate;
 271 }
 272
 273 void StyleEngine::clearMediaQueryRuleSetOnTreeScopeStyleSheets(UnorderedTreeScopeSet& treeScopes)
 274 {
 275     for (TreeScope* treeScope : treeScopes) {
 276         ASSERT(treeScope != m_document);
 277         ShadowTreeStyleSheetCollection* collection = static_cast<ShadowTreeStyleSheetCollection*>(styleSheetCollectionFor(*treeScope));
 278         ASSERT(collection);
 279         collection->clearMediaQueryRuleSetStyleSheets();
 280     }
 281 }
 282
 283 void StyleEngine::clearMediaQueryRuleSetStyleSheets()
 284 {
 285     documentStyleSheetCollection()->clearMediaQueryRuleSetStyleSheets();
 286     clearMediaQueryRuleSetOnTreeScopeStyleSheets(m_activeTreeScopes);
 287     clearMediaQueryRuleSetOnTreeScopeStyleSheets(m_dirtyTreeScopes);
 288 }
 289
 290 void StyleEngine::updateStyleSheetsInImport(DocumentStyleSheetCollector& parentCollector)
 291 {
 292     ASSERT(!isMaster());
 293     WillBeHeapVector<RefPtrWillBeMember<StyleSheet>> sheetsForList;
 294     ImportedDocumentStyleSheetCollector subcollector(parentCollector, sheetsForList);
 295     documentStyleSheetCollection()->collectStyleSheets(*this, subcollector);
 296     documentStyleSheetCollection()->swapSheetsForSheetList(sheetsForList);
 297 }
 298
 299 void StyleEngine::updateActiveStyleSheetsInShadow(StyleResolverUpdateMode updateMode, TreeScope* treeScope, UnorderedTreeScopeSet& treeScopesRemoved)
 300 {
 301     ASSERT(treeScope != m_document);
 302     ShadowTreeStyleSheetCollection* collection = static_cast<ShadowTreeStyleSheetCollection*>(styleSheetCollectionFor(*treeScope));
 303     ASSERT(collection);
 304     collection->updateActiveStyleSheets(*this, updateMode);
 305     if (!collection->hasStyleSheetCandidateNodes()) {
 306         treeScopesRemoved.add(treeScope);
 307         // When removing TreeScope from ActiveTreeScopes,
 308         // its resolver should be destroyed by invoking resetAuthorStyle.
 309         ASSERT(!treeScope->scopedStyleResolver());
 310     }
 311 }
 312
 313 void StyleEngine::updateActiveStyleSheets(StyleResolverUpdateMode updateMode)
 314 {
 315     ASSERT(isMaster());
 316     ASSERT(!document().inStyleRecalc());
 317
 318     if (!document().isActive())
 319         return;
 320
 321     if (shouldUpdateDocumentStyleSheetCollection(updateMode))
 322         documentStyleSheetCollection()->updateActiveStyleSheets(*this, updateMode);
 323
 324     if (shouldUpdateShadowTreeStyleSheetCollection(updateMode)) {
 325         UnorderedTreeScopeSet treeScopesRemoved;
 326
 327         if (updateMode == FullStyleUpdate) {
 328             for (TreeScope* treeScope : m_activeTreeScopes)
 329                 updateActiveStyleSheetsInShadow(updateMode, treeScope, treeScopesRemoved);
 330         } else {
 331             for (TreeScope* treeScope : m_dirtyTreeScopes)
 332                 updateActiveStyleSheetsInShadow(updateMode, treeScope, treeScopesRemoved);
 333         }
 334         for (TreeScope* treeScope : treeScopesRemoved)
 335             m_activeTreeScopes.remove(treeScope);
 336     }
 337
 338     InspectorInstrumentation::activeStyleSheetsUpdated(m_document);
 339
 340     m_dirtyTreeScopes.clear();
 341     m_documentScopeDirty = false;
 342 }
 343
 344 const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet>> StyleEngine::activeStyleSheetsForInspector() const
 345 {
 346     if (m_activeTreeScopes.isEmpty())
 347         return documentStyleSheetCollection()->activeAuthorStyleSheets();
 348
 349     WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet>> activeStyleSheets;
 350
 351     activeStyleSheets.appendVector(documentStyleSheetCollection()->activeAuthorStyleSheets());
 352     for (TreeScope* treeScope : m_activeTreeScopes) {
 353         if (TreeScopeStyleSheetCollection* collection = m_styleSheetCollectionMap.get(treeScope))
 354             activeStyleSheets.appendVector(collection->activeAuthorStyleSheets());
 355     }
 356
 357     // FIXME: Inspector needs a vector which has all active stylesheets.
 358     // However, creating such a large vector might cause performance regression.
 359     // Need to implement some smarter solution.
 360     return activeStyleSheets;
 361 }
 362
 363 void StyleEngine::didRemoveShadowRoot(ShadowRoot* shadowRoot)
 364 {
 365     m_styleSheetCollectionMap.remove(shadowRoot);
 366     m_activeTreeScopes.remove(shadowRoot);
 367     m_dirtyTreeScopes.remove(shadowRoot);
 368 }
 369
 370 void StyleEngine::shadowRootRemovedFromDocument(ShadowRoot* shadowRoot)
 371 {
 372     if (StyleResolver* styleResolver = resolver()) {
 373         styleResolver->resetAuthorStyle(*shadowRoot);
 374
 375         if (TreeScopeStyleSheetCollection* collection = styleSheetCollectionFor(*shadowRoot))
 376             styleResolver->removePendingAuthorStyleSheets(collection->activeAuthorStyleSheets());
 377     }
 378     m_styleSheetCollectionMap.remove(shadowRoot);
 379     m_activeTreeScopes.remove(shadowRoot);
 380     m_dirtyTreeScopes.remove(shadowRoot);
 381 }
 382
 383 void StyleEngine::appendActiveAuthorStyleSheets()
 384 {
 385     ASSERT(isMaster());
 386
 387     m_resolver->appendAuthorStyleSheets(documentStyleSheetCollection()->activeAuthorStyleSheets());
 388     for (TreeScope* treeScope : m_activeTreeScopes) {
 389         if (TreeScopeStyleSheetCollection* collection = m_styleSheetCollectionMap.get(treeScope))
 390             m_resolver->appendAuthorStyleSheets(collection->activeAuthorStyleSheets());
 391     }
 392     m_resolver->finishAppendAuthorStyleSheets();
 393 }
 394
 395 void StyleEngine::createResolver()
 396 {
 397     TRACE_EVENT1("blink", "StyleEngine::createResolver", "frame", document().frame());
 398     // It is a programming error to attempt to resolve style on a Document
 399     // which is not in a frame. Code which hits this should have checked
 400     // Document::isActive() before calling into code which could get here.
 401
 402     ASSERT(document().frame());
 403
 404     m_resolver = adoptPtrWillBeNoop(new StyleResolver(*m_document));
 405
 406     // A scoped style resolver for document will be created during
 407     // appendActiveAuthorStyleSheets if needed.
 408     appendActiveAuthorStyleSheets();
 409     combineCSSFeatureFlags(m_resolver->ensureUpdatedRuleFeatureSet());
 410 }
 411
 412 void StyleEngine::clearResolver()
 413 {
 414     ASSERT(!document().inStyleRecalc());
 415     ASSERT(isMaster() || !m_resolver);
 416
 417     document().clearScopedStyleResolver();
 418     // StyleEngine::shadowRootRemovedFromDocument removes not-in-document
 419     // treescopes from activeTreeScopes. StyleEngine::didRemoveShadowRoot
 420     // removes treescopes which are being destroyed from activeTreeScopes.
 421     // So we need to clearScopedStyleResolver for treescopes which have been
 422     // just removed from document. If document is destroyed before invoking
 423     // updateActiveStyleSheets, the treescope has a scopedStyleResolver which
 424     // has destroyed StyleSheetContents.
 425     for (TreeScope* treeScope : m_activeTreeScopes)
 426         treeScope->clearScopedStyleResolver();
 427
 428     if (m_resolver) {
 429         TRACE_EVENT1("blink", "StyleEngine::clearResolver", "frame", document().frame());
 430         m_resolver.clear();
 431     }
 432 }
 433
 434 void StyleEngine::clearMasterResolver()
 435 {
 436     if (Document* master = this->master())
 437         master->styleEngine().clearResolver();
 438 }
 439
 440 unsigned StyleEngine::resolverAccessCount() const
 441 {
 442     return m_resolver ? m_resolver->accessCount() : 0;
 443 }
 444
 445 void StyleEngine::didDetach()
 446 {
 447     clearResolver();
 448 }
 449
 450 bool StyleEngine::shouldClearResolver() const
 451 {
 452     return !m_didCalculateResolver && !haveStylesheetsLoaded();
 453 }
 454
 455 void StyleEngine::resolverChanged(StyleResolverUpdateMode mode)
 456 {
 457     if (!isMaster()) {
 458         if (Document* master = this->master())
 459             master->styleResolverChanged(mode);
 460         return;
 461     }
 462
 463     // Don't bother updating, since we haven't loaded all our style info yet
 464     // and haven't calculated the style selector for the first time.
 465     if (!document().isActive() || shouldClearResolver()) {
 466         clearResolver();
 467         return;
 468     }
 469
 470     m_didCalculateResolver = true;
 471     updateActiveStyleSheets(mode);
 472 }
 473
 474 void StyleEngine::clearFontCache()
 475 {
 476     if (m_fontSelector)
 477         m_fontSelector->fontFaceCache()->clearCSSConnected();
 478     if (m_resolver)
 479         m_resolver->invalidateMatchedPropertiesCache();
 480 }
 481
 482 void StyleEngine::updateGenericFontFamilySettings()
 483 {
 484     // FIXME: we should not update generic font family settings when
 485     // document is inactive.
 486     ASSERT(document().isActive());
 487
 488     if (!m_fontSelector)
 489         return;
 490
 491     m_fontSelector->updateGenericFontFamilySettings(*m_document);
 492     if (m_resolver)
 493         m_resolver->invalidateMatchedPropertiesCache();
 494 }
 495
 496 void StyleEngine::removeFontFaceRules(const WillBeHeapVector<RawPtrWillBeMember<const StyleRuleFontFace>>& fontFaceRules)
 497 {
 498     if (!m_fontSelector)
 499         return;
 500
 501     FontFaceCache* cache = m_fontSelector->fontFaceCache();
 502     for (unsigned i = 0; i < fontFaceRules.size(); ++i)
 503         cache->remove(fontFaceRules[i]);
 504     if (m_resolver)
 505         m_resolver->invalidateMatchedPropertiesCache();
 506 }
 507
 508 void StyleEngine::markTreeScopeDirty(TreeScope& scope)
 509 {
 510     if (scope == m_document) {
 511         markDocumentDirty();
 512         return;
 513     }
 514
 515     ASSERT(m_styleSheetCollectionMap.contains(&scope));
 516     m_dirtyTreeScopes.add(&scope);
 517 }
 518
 519 void StyleEngine::markDocumentDirty()
 520 {
 521     m_documentScopeDirty = true;
 522     if (document().importLoader())
 523         document().importsController()->master()->styleEngine().markDocumentDirty();
 524 }
 525
 526 static bool isCacheableForStyleElement(const StyleSheetContents& contents)
 527 {
 528     // FIXME: Support copying import rules.
 529     if (!contents.importRules().isEmpty())
 530         return false;
 531     // Until import rules are supported in cached sheets it's not possible for loading to fail.
 532     ASSERT(!contents.didLoadErrorOccur());
 533     // It is not the original sheet anymore.
 534     if (contents.isMutable())
 535         return false;
 536     if (!contents.hasSyntacticallyValidCSSHeader())
 537         return false;
 538     return true;
 539 }
 540
 541 PassRefPtrWillBeRawPtr<CSSStyleSheet> StyleEngine::createSheet(Element* e, const String& text, TextPosition startPosition)
 542 {
 543     RefPtrWillBeRawPtr<CSSStyleSheet> styleSheet = nullptr;
 544
 545     e->document().styleEngine().addPendingSheet();
 546
 547     AtomicString textContent(text);
 548
 549     WillBeHeapHashMap<AtomicString, RawPtrWillBeMember<StyleSheetContents>>::AddResult result = m_textToSheetCache.add(textContent, nullptr);
 550     if (result.isNewEntry || !result.storedValue->value) {
 551         styleSheet = StyleEngine::parseSheet(e, text, startPosition);
 552         if (result.isNewEntry && isCacheableForStyleElement(*styleSheet->contents())) {
 553             result.storedValue->value = styleSheet->contents();
 554             m_sheetToTextCache.add(styleSheet->contents(), textContent);
 555         }
 556     } else {
 557         StyleSheetContents* contents = result.storedValue->value;
 558         ASSERT(contents);
 559         ASSERT(isCacheableForStyleElement(*contents));
 560         ASSERT(contents->singleOwnerDocument() == e->document());
 561         styleSheet = CSSStyleSheet::createInline(contents, e, startPosition);
 562     }
 563
 564     ASSERT(styleSheet);
 565     styleSheet->setTitle(e->title());
 566     return styleSheet;
 567 }
 568
 569 PassRefPtrWillBeRawPtr<CSSStyleSheet> StyleEngine::parseSheet(Element* e, const String& text, TextPosition startPosition)
 570 {
 571     RefPtrWillBeRawPtr<CSSStyleSheet> styleSheet = nullptr;
 572     styleSheet = CSSStyleSheet::createInline(e, KURL(), startPosition, e->document().characterSet());
 573     styleSheet->contents()->parseStringAtPosition(text, startPosition);
 574     return styleSheet;
 575 }
 576
 577 void StyleEngine::removeSheet(StyleSheetContents* contents)
 578 {
 579     WillBeHeapHashMap<RawPtrWillBeMember<StyleSheetContents>, AtomicString>::iterator it = m_sheetToTextCache.find(contents);
 580     if (it == m_sheetToTextCache.end())
 581         return;
 582
 583     m_textToSheetCache.remove(it->value);
 584     m_sheetToTextCache.remove(contents);
 585 }
 586
 587 void StyleEngine::collectScopedStyleFeaturesTo(RuleFeatureSet& features) const
 588 {
 589     HashSet<const StyleSheetContents*> visitedSharedStyleSheetContents;
 590     if (document().scopedStyleResolver())
 591         document().scopedStyleResolver()->collectFeaturesTo(features, visitedSharedStyleSheetContents);
 592     for (TreeScope* treeScope : m_activeTreeScopes) {
 593         // When creating StyleResolver, dirty treescopes might not be processed.
 594         // So some active treescopes might not have a scoped style resolver.
 595         // In this case, we should skip collectFeatures for the treescopes without
 596         // scoped style resolvers. When invoking updateActiveStyleSheets,
 597         // the treescope's features will be processed.
 598         if (ScopedStyleResolver* resolver = treeScope->scopedStyleResolver())
 599             resolver->collectFeaturesTo(features, visitedSharedStyleSheetContents);
 600     }
 601 }
 602
 603 void StyleEngine::fontsNeedUpdate(CSSFontSelector*)
 604 {
 605     if (!document().isActive())
 606         return;
 607
 608     if (m_resolver)
 609         m_resolver->invalidateMatchedPropertiesCache();
 610     document().setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::Fonts));
 611 }
 612
 613 void StyleEngine::setFontSelector(PassRefPtrWillBeRawPtr<CSSFontSelector> fontSelector)
 614 {
 615 #if !ENABLE(OILPAN)
 616     if (m_fontSelector)
 617         m_fontSelector->unregisterForInvalidationCallbacks(this);
 618 #endif
 619     m_fontSelector = fontSelector;
 620     if (m_fontSelector)
 621         m_fontSelector->registerForInvalidationCallbacks(this);
 622 }
 623
 624 void StyleEngine::platformColorsChanged()
 625 {
 626     if (m_resolver)
 627         m_resolver->invalidateMatchedPropertiesCache();
 628     document().setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::PlatformColorChange));
 629 }
 630
 631 void StyleEngine::classChangedForElement(const SpaceSplitString& changedClasses, Element& element)
 632 {
 633     ASSERT(isMaster());
 634     InvalidationSetVector invalidationSets;
 635     unsigned changedSize = changedClasses.size();
 636     RuleFeatureSet& ruleFeatureSet = ensureResolver().ensureUpdatedRuleFeatureSet();
 637     for (unsigned i = 0; i < changedSize; ++i)
 638         ruleFeatureSet.collectInvalidationSetsForClass(invalidationSets, element, changedClasses[i]);
 639     scheduleInvalidationSetsForElement(invalidationSets, element);
 640 }
 641
 642 void StyleEngine::classChangedForElement(const SpaceSplitString& oldClasses, const SpaceSplitString& newClasses, Element& element)
 643 {
 644     ASSERT(isMaster());
 645     InvalidationSetVector invalidationSets;
 646     if (!oldClasses.size()) {
 647         classChangedForElement(newClasses, element);
 648         return;
 649     }
 650
 651     // Class vectors tend to be very short. This is faster than using a hash table.
 652     BitVector remainingClassBits;
 653     remainingClassBits.ensureSize(oldClasses.size());
 654
 655     RuleFeatureSet& ruleFeatureSet = ensureResolver().ensureUpdatedRuleFeatureSet();
 656
 657     for (unsigned i = 0; i < newClasses.size(); ++i) {
 658         bool found = false;
 659         for (unsigned j = 0; j < oldClasses.size(); ++j) {
 660             if (newClasses[i] == oldClasses[j]) {
 661                 // Mark each class that is still in the newClasses so we can skip doing
 662                 // an n^2 search below when looking for removals. We can't break from
 663                 // this loop early since a class can appear more than once.
 664                 remainingClassBits.quickSet(j);
 665                 found = true;
 666             }
 667         }
 668         // Class was added.
 669         if (!found)
 670             ruleFeatureSet.collectInvalidationSetsForClass(invalidationSets, element, newClasses[i]);
 671     }
 672
 673     for (unsigned i = 0; i < oldClasses.size(); ++i) {
 674         if (remainingClassBits.quickGet(i))
 675             continue;
 676         // Class was removed.
 677         ruleFeatureSet.collectInvalidationSetsForClass(invalidationSets, element, oldClasses[i]);
 678     }
 679
 680     scheduleInvalidationSetsForElement(invalidationSets, element);
 681 }
 682
 683 void StyleEngine::attributeChangedForElement(const QualifiedName& attributeName, Element& element)
 684 {
 685     ASSERT(isMaster());
 686     InvalidationSetVector invalidationSets;
 687     ensureResolver().ensureUpdatedRuleFeatureSet().collectInvalidationSetsForAttribute(invalidationSets, element, attributeName);
 688     scheduleInvalidationSetsForElement(invalidationSets, element);
 689 }
 690
 691 void StyleEngine::idChangedForElement(const AtomicString& oldId, const AtomicString& newId, Element& element)
 692 {
 693     ASSERT(isMaster());
 694     InvalidationSetVector invalidationSets;
 695     RuleFeatureSet& ruleFeatureSet = ensureResolver().ensureUpdatedRuleFeatureSet();
 696     if (!oldId.isEmpty())
 697         ruleFeatureSet.collectInvalidationSetsForId(invalidationSets, element, oldId);
 698     if (!newId.isEmpty())
 699         ruleFeatureSet.collectInvalidationSetsForId(invalidationSets, element, newId);
 700     scheduleInvalidationSetsForElement(invalidationSets, element);
 701 }
 702
 703 void StyleEngine::pseudoStateChangedForElement(CSSSelector::PseudoType pseudoType, Element& element)
 704 {
 705     ASSERT(isMaster());
 706     InvalidationSetVector invalidationSets;
 707     ensureResolver().ensureUpdatedRuleFeatureSet().collectInvalidationSetsForPseudoClass(invalidationSets, element, pseudoType);
 708     scheduleInvalidationSetsForElement(invalidationSets, element);
 709 }
 710
 711 void StyleEngine::scheduleInvalidationSetsForElement(const InvalidationSetVector& invalidationSets, Element& element)
 712 {
 713     for (auto invalidationSet : invalidationSets)
 714         m_styleInvalidator.scheduleInvalidation(invalidationSet, element);
 715 }
 716
 717 DEFINE_TRACE(StyleEngine)
 718 {
 719 #if ENABLE(OILPAN)
 720     visitor->trace(m_document);
 721     visitor->trace(m_authorStyleSheets);
 722     visitor->trace(m_documentStyleSheetCollection);
 723     visitor->trace(m_styleSheetCollectionMap);
 724     visitor->trace(m_resolver);
 725     visitor->trace(m_styleInvalidator);
 726     visitor->trace(m_dirtyTreeScopes);
 727     visitor->trace(m_activeTreeScopes);
 728     visitor->trace(m_fontSelector);
 729     visitor->trace(m_textToSheetCache);
 730     visitor->trace(m_sheetToTextCache);
 731 #endif
 732     CSSFontSelectorClient::trace(visitor);
 733 }
 734
 735 }