Use weak members to cache StyleSheetContents.

third_party/WebKit/Source/core/css/StyleSheetContents.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2006, 2007, 2012 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 47 matching lines @@
 StyleSheetContents::StyleSheetContents(StyleRuleImport* ownerRule, const String& originalURL, const CSSParserContext& context)
     : m_ownerRule(ownerRule)
     , m_originalURL(originalURL)
     , m_defaultNamespace(starAtom)
     , m_hasSyntacticallyValidCSSHeader(true)
     , m_didLoadErrorOccur(false)
     , m_isMutable(false)
     , m_hasFontFaceRule(false)
     , m_hasMediaQueries(false)
     , m_hasSingleOwnerDocument(true)
+    , m_isUsedFromTextCache(false)
     , m_parserContext(context)
 {
 }
 
 StyleSheetContents::StyleSheetContents(const StyleSheetContents& o)
     : m_ownerRule(nullptr)
     , m_originalURL(o.m_originalURL)
     , m_importRules(o.m_importRules.size())
     , m_namespaceRules(o.m_namespaceRules.size())
     , m_childRules(o.m_childRules.size())
     , m_namespaces(o.m_namespaces)
     , m_defaultNamespace(o.m_defaultNamespace)
     , m_hasSyntacticallyValidCSSHeader(o.m_hasSyntacticallyValidCSSHeader)
     , m_didLoadErrorOccur(false)
     , m_isMutable(false)
     , m_hasFontFaceRule(o.m_hasFontFaceRule)
     , m_hasMediaQueries(o.m_hasMediaQueries)
     , m_hasSingleOwnerDocument(true)
+    , m_isUsedFromTextCache(false)
     , m_parserContext(o.m_parserContext)
 {
     // FIXME: Copy import rules.
     ASSERT(o.m_importRules.isEmpty());
 
     for (unsigned i = 0; i < m_childRules.size(); ++i)
         m_childRules[i] = o.m_childRules[i]->copy();
 }
 
 StyleSheetContents::~StyleSheetContents()
 {
 }
 
 void StyleSheetContents::setHasSyntacticallyValidCSSHeader(bool isValidCss)
 {
-    if (!isValidCss) {
-        if (Document* document = clientSingleOwnerDocument())
-            removeSheetFromCache(document);

[haraken, 2016/08/03 01:01:18]

For example, don't you need to explicitly remove the sheet from the cache here?

[rune, 2016/08/03 09:20:05]

I think that removeSheetFromCache here never removed anything because ending up
here for a stylesheet which is already in the cache should be guarded by a
RuleMutationScope which calls willMutateRules(). willMutateRules() used to
remove the StyleSheetContents from the cache. I have removed the explicit remove
from there as well. What happens in willMutateRules() is that the contents will
be setMutable() if there's only one sheet referring to it, and otherwise cloned
before modified. If the in-cache contents is set mutable, it will not be
cacheable and the cache-entry will be replaced if we try to create a sheet with
the same text again.

-    }
     m_hasSyntacticallyValidCSSHeader = isValidCss;
 }
 
 bool StyleSheetContents::isCacheableForResource() const
 {
     // This would require dealing with multiple clients for load callbacks.
     if (!loadCompleted())
         return false;
     // FIXME: StyleSheets with media queries can't be cached because their RuleSet
     // is processed differently based off the media queries, which might resolve
@@ skipping 424 matching lines @@
 }
 
 void StyleSheetContents::unregisterClient(CSSStyleSheet* sheet)
 {
     m_loadingClients.remove(sheet);
     m_completedClients.remove(sheet);
 
     if (!sheet->ownerDocument() || !m_loadingClients.isEmpty() || !m_completedClients.isEmpty())
         return;
 
-    if (m_hasSingleOwnerDocument)
-        removeSheetFromCache(sheet->ownerDocument());
     m_hasSingleOwnerDocument = true;
 }
 
 void StyleSheetContents::clientLoadCompleted(CSSStyleSheet* sheet)
 {
     ASSERT(m_loadingClients.contains(sheet) || !sheet->ownerDocument());
     m_loadingClients.remove(sheet);
     // In m_ownerNode->sheetLoaded, the CSSStyleSheet might be detached.
     // (i.e. clearOwnerNode was invoked.)
     // In this case, we don't need to add the stylesheet to completed clients.
     if (!sheet->ownerDocument())
         return;
     m_completedClients.add(sheet);
 }
 
 void StyleSheetContents::clientLoadStarted(CSSStyleSheet* sheet)
 {
     ASSERT(m_completedClients.contains(sheet));
     m_completedClients.remove(sheet);
     m_loadingClients.add(sheet);
 }
 
-void StyleSheetContents::removeSheetFromCache(Document* document)
-{
-    ASSERT(document);
-    document->styleEngine().removeSheet(this);
-}
-
 void StyleSheetContents::setReferencedFromResource(CSSStyleSheetResource* resource)
 {
     DCHECK(resource);
     DCHECK(!isReferencedFromResource());
     DCHECK(isCacheableForResource());
     m_referencedFromResource = resource;
 }
 
 void StyleSheetContents::clearReferencedFromResource()
 {
@@ skipping 85 matching lines @@
     visitor->trace(m_importRules);
     visitor->trace(m_namespaceRules);
     visitor->trace(m_childRules);
     visitor->trace(m_loadingClients);
     visitor->trace(m_completedClients);
     visitor->trace(m_ruleSet);
     visitor->trace(m_referencedFromResource);
 }
 
 } // namespace blink