Avoid parsing css text if there are identical inline style blocks.

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 10 matching lines @@
 #include "config.h"
 #include "core/css/StyleSheetContents.h"
 
 #include "core/css/CSSParser.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/MediaList.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
 #include "core/css/StyleRuleImport.h"
 #include "core/dom/Node.h"
+#include "core/dom/StyleEngine.h"
 #include "core/fetch/CSSStyleSheetResource.h"
 #include "platform/TraceEvent.h"
 #include "weborigin/SecurityOrigin.h"
 #include "wtf/Deque.h"
 
 namespace WebCore {
 
 // Rough size estimate for the memory cache.
 unsigned StyleSheetContents::estimatedSizeInBytes() const
 {
@@ skipping 45 matching lines @@
 
     // 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()
 {
+    StyleEngine::removeSheet(this);
     clearRules();
 }
 
-bool StyleSheetContents::isCacheable() const
+void StyleSheetContents::setMutable()
+{
+    // If the contents is changed to be mutable, it is safe not to share the contents with others.
+    if (maybeCacheable())
+        StyleEngine::removeSheet(this);
+    m_isMutable = true;

[esprehn, 2013/11/15 10:27:37]

You can't make yourself mutable like this, you have to copy on write.

[tasak, 2014/01/09 09:24:50]

I see. I moved the logic to CSSStyleSheet::willMutateRules.

+}
+
+void StyleSheetContents::setHasSyntacticallyValidCSSHeader(bool isValidCss)
+{
+    if (maybeCacheable() && !isValidCss)
+        StyleEngine::removeSheet(this);
+    m_hasSyntacticallyValidCSSHeader = isValidCss;
+}
+
+bool StyleSheetContents::maybeCacheable() const
 {
     // FIXME: Support copying import rules.
     if (!m_importRules.isEmpty())
         return false;
     // FIXME: Support cached stylesheets in import rules.
     if (m_ownerRule)
         return false;
-    // This would require dealing with multiple clients for load callbacks.
-    if (!m_loadCompleted)
-        return false;
     if (m_didLoadErrorOccur)
         return false;
     // It is not the original sheet anymore.
     if (m_isMutable)
         return false;
     // If the header is valid we are not going to need to check the SecurityOrigin.
     // FIXME: Valid mime type avoids the check too.
     if (!m_hasSyntacticallyValidCSSHeader)
         return false;
     return true;
 }
 
+bool StyleSheetContents::isCacheable() const
+{
+    // This would require dealing with multiple clients for load callbacks.
+    if (!m_loadCompleted)
+        return false;
+    return maybeCacheable();
+}
+
 void StyleSheetContents::parserAppendRule(PassRefPtr<StyleRuleBase> rule)
 {
     ASSERT(!rule->isCharsetRule());
     if (rule->isImportRule()) {
         // Parser enforces that @import rules come before anything else except @charset.
         ASSERT(m_childRules.isEmpty());
         m_importRules.append(static_cast<StyleRuleImport*>(rule.get()));
         m_importRules.last()->setParentStyleSheet(this);
         m_importRules.last()->requestStyleSheet();
         return;
@@ skipping 176 matching lines @@
 
 bool StyleSheetContents::isLoading() const
 {
     for (unsigned i = 0; i < m_importRules.size(); ++i) {
         if (m_importRules[i]->isLoading())
             return true;
     }
     return false;
 }
 
-void StyleSheetContents::checkLoaded()
+void StyleSheetContents::checkLoadedFor(PassRefPtr<Node> ownerNode)
 {
     if (isLoading())
         return;
 
     // Avoid |this| being deleted by scripts that run via
     // ScriptableDocumentParser::executeScriptsWaitingForResources().
     // See https://bugs.webkit.org/show_bug.cgi?id=95106
     RefPtr<StyleSheetContents> protect(this);
 
     StyleSheetContents* parentSheet = parentStyleSheet();
     if (parentSheet) {
-        parentSheet->checkLoaded();
+        parentSheet->checkLoadedFor(ownerNode);
         m_loadCompleted = true;
         return;
     }
-    RefPtr<Node> ownerNode = singleOwnerNode();
     if (!ownerNode) {
         m_loadCompleted = true;
         return;
     }
     m_loadCompleted = ownerNode->sheetLoaded();
     if (m_loadCompleted)
         ownerNode->notifyLoadedSheetAndAllCriticalSubresources(m_didLoadErrorOccur);
 }
 
+void StyleSheetContents::checkLoaded()
+{
+    if (isLoading())
+        return;
+
+    // Avoid |this| being deleted by scripts that run via
+    // ScriptableDocumentParser::executeScriptsWaitingForResources().
+    // See https://bugs.webkit.org/show_bug.cgi?id=95106
+    RefPtr<StyleSheetContents> protect(this);
+
+    StyleSheetContents* parentSheet = parentStyleSheet();
+    if (parentSheet) {
+        parentSheet->checkLoaded();
+        m_loadCompleted = true;
+        return;
+    }
+
+    StyleSheetContents* root = rootStyleSheet();
+    if (root->m_clients.isEmpty()) {
+        m_loadCompleted = true;
+        return;
+    }
+
+    for (unsigned i = 0; i < root->m_clients.size(); ++i) {
+        RefPtr<Node> ownerNode = m_clients[i]->ownerNode();
+        ASSERT(ownerNode);
+        bool loadCompleted = ownerNode->sheetLoaded();

[esprehn, 2013/11/15 10:27:37]

How could the sheet have loaded for one node but not the other? This doesn't
seem possible.

[tasak, 2014/01/09 09:24:50]

I see. I moved loadCompleted to CSSStyleSheet.
If CSSStyleSheet (client) is not loadCompleted, invoke sheetLoaded.

So I also changed StyleSheetContents::loadCompleted(). The method now checks all
clients.

+        ASSERT(i <= 0 || m_loadCompleted == loadCompleted);
+        m_loadCompleted = loadCompleted;
+        if (loadCompleted)
+            ownerNode->notifyLoadedSheetAndAllCriticalSubresources(m_didLoadErrorOccur);
+    }
+}
+
 void StyleSheetContents::notifyLoadedSheet(const CSSStyleSheetResource* sheet)
 {
     ASSERT(sheet);
     m_didLoadErrorOccur |= sheet->errorOccurred();
 }
 
 void StyleSheetContents::startLoadingDynamicSheet()
 {
     if (Node* owner = singleOwnerNode())
         owner->startLoadingDynamicSheet();
@@ skipping 139 matching lines @@
     m_isInMemoryCache = false;
 }
 
 void StyleSheetContents::shrinkToFit()
 {
     m_importRules.shrinkToFit();
     m_childRules.shrinkToFit();
 }
 
 }