Home | History | Annotate | Download | only in css 
      1 /*
      2  * (C) 1999-2003 Lars Knoll (knoll (at) kde.org)
      3  * Copyright (C) 2004, 2006, 2007, 2012 Apple Inc. All rights reserved.
      4  *
      5  * This library is free software; you can redistribute it and/or
      6  * modify it under the terms of the GNU Library General Public
      7  * License as published by the Free Software Foundation; either
      8  * version 2 of the License, or (at your option) any later version.
      9  *
     10  * This library is distributed in the hope that it will be useful,
     11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     13  * Library General Public License for more details.
     14  *
     15  * You should have received a copy of the GNU Library General Public License
     16  * along with this library; see the file COPYING.LIB.  If not, write to
     17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     18  * Boston, MA 02110-1301, USA.
     19  */
     20 
     21 #include "config.h"
     22 #include "core/css/StyleSheetContents.h"
     23 
     24 #include "core/css/parser/BisonCSSParser.h"
     25 #include "core/css/CSSStyleSheet.h"
     26 #include "core/css/MediaList.h"
     27 #include "core/css/StylePropertySet.h"
     28 #include "core/css/StyleRule.h"
     29 #include "core/css/StyleRuleImport.h"
     30 #include "core/dom/Document.h"
     31 #include "core/dom/Node.h"
     32 #include "core/dom/StyleEngine.h"
     33 #include "core/fetch/CSSStyleSheetResource.h"
     34 #include "core/frame/UseCounter.h"
     35 #include "platform/TraceEvent.h"
     36 #include "platform/weborigin/SecurityOrigin.h"
     37 #include "wtf/Deque.h"
     38 
     39 namespace WebCore {
     40 
     41 // Rough size estimate for the memory cache.
     42 unsigned StyleSheetContents::estimatedSizeInBytes() const
     43 {
     44     // Note that this does not take into account size of the strings hanging from various objects.
     45     // The assumption is that nearly all of of them are atomic and would exist anyway.
     46     unsigned size = sizeof(*this);
     47 
     48     // FIXME: This ignores the children of media rules.
     49     // Most rules are StyleRules.
     50     size += ruleCount() * StyleRule::averageSizeInBytes();
     51 
     52     for (unsigned i = 0; i < m_importRules.size(); ++i) {
     53         if (StyleSheetContents* sheet = m_importRules[i]->styleSheet())
     54             size += sheet->estimatedSizeInBytes();
     55     }
     56     return size;
     57 }
     58 
     59 StyleSheetContents::StyleSheetContents(StyleRuleImport* ownerRule, const String& originalURL, const CSSParserContext& context)
     60     : m_ownerRule(ownerRule)
     61     , m_originalURL(originalURL)
     62     , m_hasSyntacticallyValidCSSHeader(true)
     63     , m_didLoadErrorOccur(false)
     64     , m_usesRemUnits(false)
     65     , m_isMutable(false)
     66     , m_isInMemoryCache(false)
     67     , m_hasFontFaceRule(false)
     68     , m_hasMediaQueries(false)
     69     , m_hasSingleOwnerDocument(true)
     70     , m_parserContext(context)
     71 {
     72 }
     73 
     74 StyleSheetContents::StyleSheetContents(const StyleSheetContents& o)
     75     : m_ownerRule(nullptr)
     76     , m_originalURL(o.m_originalURL)
     77     , m_encodingFromCharsetRule(o.m_encodingFromCharsetRule)
     78     , m_importRules(o.m_importRules.size())
     79     , m_childRules(o.m_childRules.size())
     80     , m_namespaces(o.m_namespaces)
     81     , m_hasSyntacticallyValidCSSHeader(o.m_hasSyntacticallyValidCSSHeader)
     82     , m_didLoadErrorOccur(false)
     83     , m_usesRemUnits(o.m_usesRemUnits)
     84     , m_isMutable(false)
     85     , m_isInMemoryCache(false)
     86     , m_hasFontFaceRule(o.m_hasFontFaceRule)
     87     , m_hasMediaQueries(o.m_hasMediaQueries)
     88     , m_hasSingleOwnerDocument(true)
     89     , m_parserContext(o.m_parserContext)
     90 {
     91     ASSERT(o.isCacheable());
     92 
     93     // FIXME: Copy import rules.
     94     ASSERT(o.m_importRules.isEmpty());
     95 
     96     for (unsigned i = 0; i < m_childRules.size(); ++i)
     97         m_childRules[i] = o.m_childRules[i]->copy();
     98 }
     99 
    100 StyleSheetContents::~StyleSheetContents()
    101 {
    102 #if !ENABLE(OILPAN)
    103     clearRules();
    104 #endif
    105 }
    106 
    107 void StyleSheetContents::setHasSyntacticallyValidCSSHeader(bool isValidCss)
    108 {
    109     if (!isValidCss) {
    110         if (Document* document = clientSingleOwnerDocument())
    111             removeSheetFromCache(document);
    112     }
    113     m_hasSyntacticallyValidCSSHeader = isValidCss;
    114 }
    115 
    116 bool StyleSheetContents::isCacheable() const
    117 {
    118     // This would require dealing with multiple clients for load callbacks.
    119     if (!loadCompleted())
    120         return false;
    121     // FIXME: StyleSheets with media queries can't be cached because their RuleSet
    122     // is processed differently based off the media queries, which might resolve
    123     // differently depending on the context of the parent CSSStyleSheet (e.g.
    124     // if they are in differently sized iframes). Once RuleSets are media query
    125     // agnostic, we can restore sharing of StyleSheetContents with medea queries.
    126     if (m_hasMediaQueries)
    127         return false;
    128     // FIXME: Support copying import rules.
    129     if (!m_importRules.isEmpty())
    130         return false;
    131     // FIXME: Support cached stylesheets in import rules.
    132     if (m_ownerRule)
    133         return false;
    134     if (m_didLoadErrorOccur)
    135         return false;
    136     // It is not the original sheet anymore.
    137     if (m_isMutable)
    138         return false;
    139     // If the header is valid we are not going to need to check the SecurityOrigin.
    140     // FIXME: Valid mime type avoids the check too.
    141     if (!m_hasSyntacticallyValidCSSHeader)
    142         return false;
    143     return true;
    144 }
    145 
    146 void StyleSheetContents::parserAppendRule(PassRefPtrWillBeRawPtr<StyleRuleBase> rule)
    147 {
    148     ASSERT(!rule->isCharsetRule());
    149     if (rule->isImportRule()) {
    150         // Parser enforces that @import rules come before anything else except @charset.
    151         ASSERT(m_childRules.isEmpty());
    152         StyleRuleImport* importRule = toStyleRuleImport(rule.get());
    153         if (importRule->mediaQueries())
    154             setHasMediaQueries();
    155         m_importRules.append(importRule);
    156         m_importRules.last()->setParentStyleSheet(this);
    157         m_importRules.last()->requestStyleSheet();
    158         return;
    159     }
    160 
    161     // Add warning message to inspector if dpi/dpcm values are used for screen media.
    162     if (rule->isMediaRule()) {
    163         setHasMediaQueries();
    164         reportMediaQueryWarningIfNeeded(singleOwnerDocument(), toStyleRuleMedia(rule.get())->mediaQueries());
    165     }
    166 
    167     m_childRules.append(rule);
    168 }
    169 
    170 void StyleSheetContents::setHasMediaQueries()
    171 {
    172     m_hasMediaQueries = true;
    173     if (parentStyleSheet())
    174         parentStyleSheet()->setHasMediaQueries();
    175 }
    176 
    177 StyleRuleBase* StyleSheetContents::ruleAt(unsigned index) const
    178 {
    179     ASSERT_WITH_SECURITY_IMPLICATION(index < ruleCount());
    180 
    181     unsigned childVectorIndex = index;
    182     if (hasCharsetRule()) {
    183         if (index == 0)
    184             return 0;
    185         --childVectorIndex;
    186     }
    187     if (childVectorIndex < m_importRules.size())
    188         return m_importRules[childVectorIndex].get();
    189 
    190     childVectorIndex -= m_importRules.size();
    191     return m_childRules[childVectorIndex].get();
    192 }
    193 
    194 unsigned StyleSheetContents::ruleCount() const
    195 {
    196     unsigned result = 0;
    197     result += hasCharsetRule() ? 1 : 0;
    198     result += m_importRules.size();
    199     result += m_childRules.size();
    200     return result;
    201 }
    202 
    203 void StyleSheetContents::clearCharsetRule()
    204 {
    205     m_encodingFromCharsetRule = String();
    206 }
    207 
    208 void StyleSheetContents::clearRules()
    209 {
    210     for (unsigned i = 0; i < m_importRules.size(); ++i) {
    211         ASSERT(m_importRules.at(i)->parentStyleSheet() == this);
    212         m_importRules[i]->clearParentStyleSheet();
    213     }
    214     m_importRules.clear();
    215     m_childRules.clear();
    216     clearCharsetRule();
    217 }
    218 
    219 void StyleSheetContents::parserSetEncodingFromCharsetRule(const String& encoding)
    220 {
    221     // Parser enforces that there is ever only one @charset.
    222     ASSERT(m_encodingFromCharsetRule.isNull());
    223     m_encodingFromCharsetRule = encoding;
    224 }
    225 
    226 bool StyleSheetContents::wrapperInsertRule(PassRefPtrWillBeRawPtr<StyleRuleBase> rule, unsigned index)
    227 {
    228     ASSERT(m_isMutable);
    229     ASSERT_WITH_SECURITY_IMPLICATION(index <= ruleCount());
    230     // Parser::parseRule doesn't currently allow @charset so we don't need to deal with it.
    231     ASSERT(!rule->isCharsetRule());
    232 
    233     unsigned childVectorIndex = index;
    234     // m_childRules does not contain @charset which is always in index 0 if it exists.
    235     if (hasCharsetRule()) {
    236         if (childVectorIndex == 0) {
    237             // Nothing can be inserted before @charset.
    238             return false;
    239         }
    240         --childVectorIndex;
    241     }
    242 
    243     if (childVectorIndex < m_importRules.size() || (childVectorIndex == m_importRules.size() && rule->isImportRule())) {
    244         // Inserting non-import rule before @import is not allowed.
    245         if (!rule->isImportRule())
    246             return false;
    247 
    248         StyleRuleImport* importRule = toStyleRuleImport(rule.get());
    249         if (importRule->mediaQueries())
    250             setHasMediaQueries();
    251 
    252         m_importRules.insert(childVectorIndex, importRule);
    253         m_importRules[childVectorIndex]->setParentStyleSheet(this);
    254         m_importRules[childVectorIndex]->requestStyleSheet();
    255         // FIXME: Stylesheet doesn't actually change meaningfully before the imported sheets are loaded.
    256         return true;
    257     }
    258     // Inserting @import rule after a non-import rule is not allowed.
    259     if (rule->isImportRule())
    260         return false;
    261 
    262     if (rule->isMediaRule())
    263         setHasMediaQueries();
    264 
    265     childVectorIndex -= m_importRules.size();
    266 
    267     if (rule->isFontFaceRule())
    268         setHasFontFaceRule(true);
    269     m_childRules.insert(childVectorIndex, rule);
    270     return true;
    271 }
    272 
    273 void StyleSheetContents::wrapperDeleteRule(unsigned index)
    274 {
    275     ASSERT(m_isMutable);
    276     ASSERT_WITH_SECURITY_IMPLICATION(index < ruleCount());
    277 
    278     unsigned childVectorIndex = index;
    279     if (hasCharsetRule()) {
    280         if (childVectorIndex == 0) {
    281             clearCharsetRule();
    282             return;
    283         }
    284         --childVectorIndex;
    285     }
    286     if (childVectorIndex < m_importRules.size()) {
    287         m_importRules[childVectorIndex]->clearParentStyleSheet();
    288         if (m_importRules[childVectorIndex]->isFontFaceRule())
    289             notifyRemoveFontFaceRule(toStyleRuleFontFace(m_importRules[childVectorIndex].get()));
    290         m_importRules.remove(childVectorIndex);
    291         return;
    292     }
    293     childVectorIndex -= m_importRules.size();
    294 
    295     if (m_childRules[childVectorIndex]->isFontFaceRule())
    296         notifyRemoveFontFaceRule(toStyleRuleFontFace(m_childRules[childVectorIndex].get()));
    297     m_childRules.remove(childVectorIndex);
    298 }
    299 
    300 void StyleSheetContents::parserAddNamespace(const AtomicString& prefix, const AtomicString& uri)
    301 {
    302     if (uri.isNull() || prefix.isNull())
    303         return;
    304     PrefixNamespaceURIMap::AddResult result = m_namespaces.add(prefix, uri);
    305     if (result.isNewEntry)
    306         return;
    307     result.storedValue->value = uri;
    308 }
    309 
    310 const AtomicString& StyleSheetContents::determineNamespace(const AtomicString& prefix)
    311 {
    312     if (prefix.isNull())
    313         return nullAtom; // No namespace. If an element/attribute has a namespace, we won't match it.
    314     if (prefix == starAtom)
    315         return starAtom; // We'll match any namespace.
    316     return m_namespaces.get(prefix);
    317 }
    318 
    319 void StyleSheetContents::parseAuthorStyleSheet(const CSSStyleSheetResource* cachedStyleSheet, const SecurityOrigin* securityOrigin)
    320 {
    321     TRACE_EVENT0("webkit", "StyleSheetContents::parseAuthorStyleSheet");
    322 
    323     bool quirksMode = isQuirksModeBehavior(m_parserContext.mode());
    324 
    325     bool enforceMIMEType = !quirksMode;
    326     bool hasValidMIMEType = false;
    327     String sheetText = cachedStyleSheet->sheetText(enforceMIMEType, &hasValidMIMEType);
    328 
    329     CSSParserContext context(parserContext(), UseCounter::getFrom(this));
    330     BisonCSSParser p(context);
    331     p.parseSheet(this, sheetText, TextPosition::minimumPosition(), 0, true);
    332 
    333     // If we're loading a stylesheet cross-origin, and the MIME type is not standard, require the CSS
    334     // to at least start with a syntactically valid CSS rule.
    335     // This prevents an attacker playing games by injecting CSS strings into HTML, XML, JSON, etc. etc.
    336     if (!hasValidMIMEType && !hasSyntacticallyValidCSSHeader()) {
    337         bool isCrossOriginCSS = !securityOrigin || !securityOrigin->canRequest(baseURL());
    338         if (isCrossOriginCSS) {
    339             clearRules();
    340             return;
    341         }
    342     }
    343 }
    344 
    345 bool StyleSheetContents::parseString(const String& sheetText)
    346 {
    347     return parseStringAtPosition(sheetText, TextPosition::minimumPosition(), false);
    348 }
    349 
    350 bool StyleSheetContents::parseStringAtPosition(const String& sheetText, const TextPosition& startPosition, bool createdByParser)
    351 {
    352     CSSParserContext context(parserContext(), UseCounter::getFrom(this));
    353     BisonCSSParser p(context);
    354     p.parseSheet(this, sheetText, startPosition, 0, createdByParser);
    355 
    356     return true;
    357 }
    358 
    359 bool StyleSheetContents::isLoading() const
    360 {
    361     for (unsigned i = 0; i < m_importRules.size(); ++i) {
    362         if (m_importRules[i]->isLoading())
    363             return true;
    364     }
    365     return false;
    366 }
    367 
    368 bool StyleSheetContents::loadCompleted() const
    369 {
    370     StyleSheetContents* parentSheet = parentStyleSheet();
    371     if (parentSheet)
    372         return parentSheet->loadCompleted();
    373 
    374     StyleSheetContents* root = rootStyleSheet();
    375     return root->m_loadingClients.isEmpty();
    376 }
    377 
    378 void StyleSheetContents::checkLoaded()
    379 {
    380     if (isLoading())
    381         return;
    382 
    383     // Avoid |this| being deleted by scripts that run via
    384     // ScriptableDocumentParser::executeScriptsWaitingForResources().
    385     // See https://bugs.webkit.org/show_bug.cgi?id=95106
    386     RefPtrWillBeRawPtr<StyleSheetContents> protect(this);
    387 
    388     StyleSheetContents* parentSheet = parentStyleSheet();
    389     if (parentSheet) {
    390         parentSheet->checkLoaded();
    391         return;
    392     }
    393 
    394     StyleSheetContents* root = rootStyleSheet();
    395     if (root->m_loadingClients.isEmpty())
    396         return;
    397 
    398     // Avoid |CSSSStyleSheet| and |ownerNode| being deleted by scripts that run via
    399     // ScriptableDocumentParser::executeScriptsWaitingForResources(). Also protect
    400     // the |CSSStyleSheet| from being deleted during iteration via the |sheetLoaded|
    401     // method.
    402     //
    403     // When a sheet is loaded it is moved from the set of loading clients
    404     // to the set of completed clients. We therefore need the copy in order to
    405     // not modify the set while iterating it.
    406     WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet> > loadingClients;
    407     copyToVector(m_loadingClients, loadingClients);
    408 
    409     for (unsigned i = 0; i < loadingClients.size(); ++i) {
    410         if (loadingClients[i]->loadCompleted())
    411             continue;
    412 
    413         // sheetLoaded might be invoked after its owner node is removed from document.
    414         if (RefPtrWillBeRawPtr<Node> ownerNode = loadingClients[i]->ownerNode()) {
    415             if (loadingClients[i]->sheetLoaded())
    416                 ownerNode->notifyLoadedSheetAndAllCriticalSubresources(m_didLoadErrorOccur);
    417         }
    418     }
    419 }
    420 
    421 void StyleSheetContents::notifyLoadedSheet(const CSSStyleSheetResource* sheet)
    422 {
    423     ASSERT(sheet);
    424     m_didLoadErrorOccur |= sheet->errorOccurred();
    425     // updateLayoutIgnorePendingStyleSheets can cause us to create the RuleSet on this
    426     // sheet before its imports have loaded. So clear the RuleSet when the imports
    427     // load since the import's subrules are flattened into its parent sheet's RuleSet.
    428     clearRuleSet();
    429 }
    430 
    431 void StyleSheetContents::startLoadingDynamicSheet()
    432 {
    433     StyleSheetContents* root = rootStyleSheet();
    434     for (ClientsIterator it = root->m_loadingClients.begin(); it != root->m_loadingClients.end(); ++it)
    435         (*it)->startLoadingDynamicSheet();
    436     // Copy the completed clients to a vector for iteration.
    437     // startLoadingDynamicSheet will move the style sheet from the
    438     // completed state to the loading state which modifies the set of
    439     // completed clients. We therefore need the copy in order to not
    440     // modify the set of completed clients while iterating it.
    441     WillBeHeapVector<RawPtrWillBeMember<CSSStyleSheet> > completedClients;
    442     copyToVector(root->m_completedClients, completedClients);
    443     for (unsigned i = 0; i < completedClients.size(); ++i)
    444         completedClients[i]->startLoadingDynamicSheet();
    445 }
    446 
    447 StyleSheetContents* StyleSheetContents::rootStyleSheet() const
    448 {
    449     const StyleSheetContents* root = this;
    450     while (root->parentStyleSheet())
    451         root = root->parentStyleSheet();
    452     return const_cast<StyleSheetContents*>(root);
    453 }
    454 
    455 bool StyleSheetContents::hasSingleOwnerNode() const
    456 {
    457     return rootStyleSheet()->hasOneClient();
    458 }
    459 
    460 Node* StyleSheetContents::singleOwnerNode() const
    461 {
    462     StyleSheetContents* root = rootStyleSheet();
    463     if (!root->hasOneClient())
    464         return 0;
    465     if (root->m_loadingClients.size())
    466         return (*root->m_loadingClients.begin())->ownerNode();
    467     return (*root->m_completedClients.begin())->ownerNode();
    468 }
    469 
    470 Document* StyleSheetContents::singleOwnerDocument() const
    471 {
    472     StyleSheetContents* root = rootStyleSheet();
    473     return root->clientSingleOwnerDocument();
    474 }
    475 
    476 KURL StyleSheetContents::completeURL(const String& url) const
    477 {
    478     // FIXME: This is only OK when we have a singleOwnerNode, right?
    479     return m_parserContext.completeURL(url);
    480 }
    481 
    482 static bool childRulesHaveFailedOrCanceledSubresources(const WillBeHeapVector<RefPtrWillBeMember<StyleRuleBase> >& rules)
    483 {
    484     for (unsigned i = 0; i < rules.size(); ++i) {
    485         const StyleRuleBase* rule = rules[i].get();
    486         switch (rule->type()) {
    487         case StyleRuleBase::Style:
    488             if (toStyleRule(rule)->properties().hasFailedOrCanceledSubresources())
    489                 return true;
    490             break;
    491         case StyleRuleBase::FontFace:
    492             if (toStyleRuleFontFace(rule)->properties().hasFailedOrCanceledSubresources())
    493                 return true;
    494             break;
    495         case StyleRuleBase::Media:
    496             if (childRulesHaveFailedOrCanceledSubresources(toStyleRuleMedia(rule)->childRules()))
    497                 return true;
    498             break;
    499         case StyleRuleBase::Import:
    500             ASSERT_NOT_REACHED();
    501         case StyleRuleBase::Page:
    502         case StyleRuleBase::Keyframes:
    503         case StyleRuleBase::Unknown:
    504         case StyleRuleBase::Charset:
    505         case StyleRuleBase::Keyframe:
    506         case StyleRuleBase::Supports:
    507         case StyleRuleBase::Viewport:
    508         case StyleRuleBase::Filter:
    509             break;
    510         }
    511     }
    512     return false;
    513 }
    514 
    515 bool StyleSheetContents::hasFailedOrCanceledSubresources() const
    516 {
    517     ASSERT(isCacheable());
    518     return childRulesHaveFailedOrCanceledSubresources(m_childRules);
    519 }
    520 
    521 Document* StyleSheetContents::clientSingleOwnerDocument() const
    522 {
    523     if (!m_hasSingleOwnerDocument || clientSize() <= 0)
    524         return 0;
    525 
    526     if (m_loadingClients.size())
    527         return (*m_loadingClients.begin())->ownerDocument();
    528     return (*m_completedClients.begin())->ownerDocument();
    529 }
    530 
    531 StyleSheetContents* StyleSheetContents::parentStyleSheet() const
    532 {
    533     return m_ownerRule ? m_ownerRule->parentStyleSheet() : 0;
    534 }
    535 
    536 void StyleSheetContents::registerClient(CSSStyleSheet* sheet)
    537 {
    538     ASSERT(!m_loadingClients.contains(sheet) && !m_completedClients.contains(sheet));
    539 
    540     // InspectorCSSAgent::buildObjectForRule creates CSSStyleSheet without any owner node.
    541     if (!sheet->ownerDocument())
    542         return;
    543 
    544     if (Document* document = clientSingleOwnerDocument()) {
    545         if (sheet->ownerDocument() != document)
    546             m_hasSingleOwnerDocument = false;
    547     }
    548     m_loadingClients.add(sheet);
    549 }
    550 
    551 void StyleSheetContents::unregisterClient(CSSStyleSheet* sheet)
    552 {
    553     m_loadingClients.remove(sheet);
    554     m_completedClients.remove(sheet);
    555 
    556     if (!sheet->ownerDocument() || !m_loadingClients.isEmpty() || !m_completedClients.isEmpty())
    557         return;
    558 
    559     if (m_hasSingleOwnerDocument)
    560         removeSheetFromCache(sheet->ownerDocument());
    561     m_hasSingleOwnerDocument = true;
    562 }
    563 
    564 void StyleSheetContents::clientLoadCompleted(CSSStyleSheet* sheet)
    565 {
    566     ASSERT(m_loadingClients.contains(sheet) || !sheet->ownerDocument());
    567     m_loadingClients.remove(sheet);
    568     // In m_ownerNode->sheetLoaded, the CSSStyleSheet might be detached.
    569     // (i.e. clearOwnerNode was invoked.)
    570     // In this case, we don't need to add the stylesheet to completed clients.
    571     if (!sheet->ownerDocument())
    572         return;
    573     m_completedClients.add(sheet);
    574 }
    575 
    576 void StyleSheetContents::clientLoadStarted(CSSStyleSheet* sheet)
    577 {
    578     ASSERT(m_completedClients.contains(sheet));
    579     m_completedClients.remove(sheet);
    580     m_loadingClients.add(sheet);
    581 }
    582 
    583 void StyleSheetContents::removeSheetFromCache(Document* document)
    584 {
    585     ASSERT(document);
    586     document->styleEngine()->removeSheet(this);
    587 }
    588 
    589 void StyleSheetContents::addedToMemoryCache()
    590 {
    591     ASSERT(!m_isInMemoryCache);
    592     ASSERT(isCacheable());
    593     m_isInMemoryCache = true;
    594 }
    595 
    596 void StyleSheetContents::removedFromMemoryCache()
    597 {
    598     ASSERT(m_isInMemoryCache);
    599     ASSERT(isCacheable());
    600     m_isInMemoryCache = false;
    601 }
    602 
    603 void StyleSheetContents::shrinkToFit()
    604 {
    605     m_importRules.shrinkToFit();
    606     m_childRules.shrinkToFit();
    607 }
    608 
    609 RuleSet& StyleSheetContents::ensureRuleSet(const MediaQueryEvaluator& medium, AddRuleFlags addRuleFlags)
    610 {
    611     if (!m_ruleSet) {
    612         m_ruleSet = RuleSet::create();
    613         m_ruleSet->addRulesFromSheet(this, medium, addRuleFlags);
    614     }
    615     return *m_ruleSet.get();
    616 }
    617 
    618 static void clearResolvers(WillBeHeapHashSet<RawPtrWillBeWeakMember<CSSStyleSheet> >& clients)
    619 {
    620     for (WillBeHeapHashSet<RawPtrWillBeWeakMember<CSSStyleSheet> >::iterator it = clients.begin(); it != clients.end(); ++it) {
    621         if (Document* document = (*it)->ownerDocument())
    622             document->styleEngine()->clearResolver();
    623     }
    624 }
    625 
    626 void StyleSheetContents::clearRuleSet()
    627 {
    628     if (StyleSheetContents* parentSheet = parentStyleSheet())
    629         parentSheet->clearRuleSet();
    630 
    631     // Don't want to clear the StyleResolver if the RuleSet hasn't been created
    632     // since we only clear the StyleResolver so that it's members are properly
    633     // updated in ScopedStyleResolver::addRulesFromSheet.
    634     if (!m_ruleSet)
    635         return;
    636 
    637     // Clearing the ruleSet means we need to recreate the styleResolver data structures.
    638     // See the StyleResolver calls in ScopedStyleResolver::addRulesFromSheet.
    639     clearResolvers(m_loadingClients);
    640     clearResolvers(m_completedClients);
    641     m_ruleSet.clear();
    642 }
    643 
    644 static void removeFontFaceRules(WillBeHeapHashSet<RawPtrWillBeWeakMember<CSSStyleSheet> >& clients, const StyleRuleFontFace* fontFaceRule)
    645 {
    646     for (WillBeHeapHashSet<RawPtrWillBeWeakMember<CSSStyleSheet> >::iterator it = clients.begin(); it != clients.end(); ++it) {
    647         if (Node* ownerNode = (*it)->ownerNode())
    648             ownerNode->document().styleEngine()->removeFontFaceRules(WillBeHeapVector<RawPtrWillBeMember<const StyleRuleFontFace> >(1, fontFaceRule));
    649     }
    650 }
    651 
    652 void StyleSheetContents::notifyRemoveFontFaceRule(const StyleRuleFontFace* fontFaceRule)
    653 {
    654     StyleSheetContents* root = rootStyleSheet();
    655     removeFontFaceRules(root->m_loadingClients, fontFaceRule);
    656     removeFontFaceRules(root->m_completedClients, fontFaceRule);
    657 }
    658 
    659 static void findFontFaceRulesFromRules(const WillBeHeapVector<RefPtrWillBeMember<StyleRuleBase> >& rules, WillBeHeapVector<RawPtrWillBeMember<const StyleRuleFontFace> >& fontFaceRules)
    660 {
    661     for (unsigned i = 0; i < rules.size(); ++i) {
    662         StyleRuleBase* rule = rules[i].get();
    663 
    664         if (rule->isFontFaceRule()) {
    665             fontFaceRules.append(toStyleRuleFontFace(rule));
    666         } else if (rule->isMediaRule()) {
    667             StyleRuleMedia* mediaRule = toStyleRuleMedia(rule);
    668             // We cannot know whether the media rule matches or not, but
    669             // for safety, remove @font-face in the media rule (if exists).
    670             findFontFaceRulesFromRules(mediaRule->childRules(), fontFaceRules);
    671         }
    672     }
    673 }
    674 
    675 void StyleSheetContents::findFontFaceRules(WillBeHeapVector<RawPtrWillBeMember<const StyleRuleFontFace> >& fontFaceRules)
    676 {
    677     for (unsigned i = 0; i < m_importRules.size(); ++i) {
    678         if (!m_importRules[i]->styleSheet())
    679             continue;
    680         m_importRules[i]->styleSheet()->findFontFaceRules(fontFaceRules);
    681     }
    682 
    683     findFontFaceRulesFromRules(childRules(), fontFaceRules);
    684 }
    685 
    686 void StyleSheetContents::trace(Visitor* visitor)
    687 {
    688     visitor->trace(m_ownerRule);
    689     visitor->trace(m_importRules);
    690     visitor->trace(m_childRules);
    691     visitor->trace(m_loadingClients);
    692     visitor->trace(m_completedClients);
    693     visitor->trace(m_ruleSet);
    694 }
    695 
    696 }
    697