1 files changed, 96 insertions, 76 deletions

diff --git a/Source/WebCore/css/CSSDefaultStyleSheets.cpp b/Source/WebCore/css/CSSDefaultStyleSheets.cpp
index e70024313..b9b40dd8a 100644
--- a/Source/WebCore/css/CSSDefaultStyleSheets.cpp
+++ b/Source/WebCore/css/CSSDefaultStyleSheets.cpp
@@ -33,12 +33,24 @@
 #include "ChromeClient.h"
 #include "HTMLAnchorElement.h"
 #include "HTMLAudioElement.h"
+#include "HTMLBRElement.h"
+#include "HTMLBodyElement.h"
+#include "HTMLDivElement.h"
+#include "HTMLEmbedElement.h"
+#include "HTMLHeadElement.h"
+#include "HTMLHtmlElement.h"
+#include "HTMLObjectElement.h"
+#include "HTMLSpanElement.h"
+#include "MathMLElement.h"
 #include "MediaQueryEvaluator.h"
 #include "Page.h"
 #include "RenderTheme.h"
 #include "RuleSet.h"
+#include "RuntimeEnabledFeatures.h"
+#include "SVGElement.h"
 #include "StyleSheetContents.h"
 #include "UserAgentStyleSheets.h"
+#include <wtf/NeverDestroyed.h>
 
 namespace WebCore {
 
@@ -47,7 +59,7 @@ using namespace HTMLNames;
 RuleSet* CSSDefaultStyleSheets::defaultStyle;
 RuleSet* CSSDefaultStyleSheets::defaultQuirksStyle;
 RuleSet* CSSDefaultStyleSheets::defaultPrintStyle;
-RuleSet* CSSDefaultStyleSheets::defaultViewSourceStyle;
+unsigned CSSDefaultStyleSheets::defaultStyleVersion;
 
 StyleSheetContents* CSSDefaultStyleSheets::simpleDefaultStyleSheet;
 StyleSheetContents* CSSDefaultStyleSheets::defaultStyleSheet;
@@ -57,30 +69,34 @@ StyleSheetContents* CSSDefaultStyleSheets::mathMLStyleSheet;
 StyleSheetContents* CSSDefaultStyleSheets::mediaControlsStyleSheet;
 StyleSheetContents* CSSDefaultStyleSheets::fullscreenStyleSheet;
 StyleSheetContents* CSSDefaultStyleSheets::plugInsStyleSheet;
+StyleSheetContents* CSSDefaultStyleSheets::imageControlsStyleSheet;
 
 // FIXME: It would be nice to use some mechanism that guarantees this is in sync with the real UA stylesheet.
-static const char* simpleUserAgentStyleSheet = "html,body,div{display:block}head{display:none}body{margin:8px}div:focus,span:focus,a:focus{outline:auto 5px -webkit-focus-ring-color}a:-webkit-any-link{color:-webkit-link;text-decoration:underline}a:-webkit-any-link:active{color:-webkit-activelink}";
+static const char* simpleUserAgentStyleSheet = "html,body,div{display:block}head{display:none}body{margin:8px}div:focus,span:focus,a:focus{outline:auto 5px -webkit-focus-ring-color}a:any-link{color:-webkit-link;text-decoration:underline}a:any-link:active{color:-webkit-activelink}";
 
-static inline bool elementCanUseSimpleDefaultStyle(Element* e)
+static inline bool elementCanUseSimpleDefaultStyle(const Element& element)
 {
-    return e->hasTagName(htmlTag) || e->hasTagName(headTag) || e->hasTagName(bodyTag) || e->hasTagName(divTag) || e->hasTagName(spanTag) || e->hasTagName(brTag) || isHTMLAnchorElement(e);
+    return is<HTMLHtmlElement>(element) || is<HTMLHeadElement>(element)
+        || is<HTMLBodyElement>(element) || is<HTMLDivElement>(element)
+        || is<HTMLSpanElement>(element) || is<HTMLBRElement>(element)
+        || is<HTMLAnchorElement>(element);
 }
 
 static const MediaQueryEvaluator& screenEval()
 {
-    DEFINE_STATIC_LOCAL(const MediaQueryEvaluator, staticScreenEval, ("screen"));
+    static NeverDestroyed<const MediaQueryEvaluator> staticScreenEval(String(ASCIILiteral("screen")));
     return staticScreenEval;
 }
 
 static const MediaQueryEvaluator& printEval()
 {
-    DEFINE_STATIC_LOCAL(const MediaQueryEvaluator, staticPrintEval, ("print"));
+    static NeverDestroyed<const MediaQueryEvaluator> staticPrintEval(String(ASCIILiteral("print")));
     return staticPrintEval;
 }
 
 static StyleSheetContents* parseUASheet(const String& str)
 {
-    StyleSheetContents& sheet = StyleSheetContents::create().leakRef(); // leak the sheet on purpose
+    StyleSheetContents& sheet = StyleSheetContents::create(CSSParserContext(UASheetMode)).leakRef(); // leak the sheet on purpose
     sheet.parseString(str);
     return &sheet;
 }
@@ -90,10 +106,10 @@ static StyleSheetContents* parseUASheet(const char* characters, unsigned size)
     return parseUASheet(String(characters, size));
 }
 
-void CSSDefaultStyleSheets::initDefaultStyle(Element* root)
+void CSSDefaultStyleSheets::initDefaultStyle(const Element* root)
 {
     if (!defaultStyle) {
-        if (!root || elementCanUseSimpleDefaultStyle(root))
+        if (!root || elementCanUseSimpleDefaultStyle(*root))
             loadSimpleDefaultStyle();
         else
             loadFullDefaultStyle();
@@ -107,26 +123,26 @@ void CSSDefaultStyleSheets::loadFullDefaultStyle()
         ASSERT(defaultPrintStyle == defaultStyle);
         delete defaultStyle;
         simpleDefaultStyleSheet->deref();
-        defaultStyle = RuleSet::create().leakPtr();
-        defaultPrintStyle = RuleSet::create().leakPtr();
+        defaultStyle = std::make_unique<RuleSet>().release();
+        defaultPrintStyle = std::make_unique<RuleSet>().release();
         simpleDefaultStyleSheet = 0;
     } else {
         ASSERT(!defaultStyle);
-        defaultStyle = RuleSet::create().leakPtr();
-        defaultPrintStyle = RuleSet::create().leakPtr();
-        defaultQuirksStyle = RuleSet::create().leakPtr();
+        defaultStyle = std::make_unique<RuleSet>().release();
+        defaultPrintStyle = std::make_unique<RuleSet>().release();
+        defaultQuirksStyle = std::make_unique<RuleSet>().release();
     }
 
     // Strict-mode rules.
     String defaultRules = String(htmlUserAgentStyleSheet, sizeof(htmlUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraDefaultStyleSheet();
     defaultStyleSheet = parseUASheet(defaultRules);
-    defaultStyle->addRulesFromSheet(defaultStyleSheet, screenEval());
-    defaultPrintStyle->addRulesFromSheet(defaultStyleSheet, printEval());
+    defaultStyle->addRulesFromSheet(*defaultStyleSheet, screenEval());
+    defaultPrintStyle->addRulesFromSheet(*defaultStyleSheet, printEval());
 
     // Quirks-mode rules.
     String quirksRules = String(quirksUserAgentStyleSheet, sizeof(quirksUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraQuirksStyleSheet();
     quirksStyleSheet = parseUASheet(quirksRules);
-    defaultQuirksStyle->addRulesFromSheet(quirksStyleSheet, screenEval());
+    defaultQuirksStyle->addRulesFromSheet(*quirksStyleSheet, screenEval());
 }
 
 void CSSDefaultStyleSheets::loadSimpleDefaultStyle()
@@ -134,85 +150,89 @@ void CSSDefaultStyleSheets::loadSimpleDefaultStyle()
     ASSERT(!defaultStyle);
     ASSERT(!simpleDefaultStyleSheet);
 
-    defaultStyle = RuleSet::create().leakPtr();
+    defaultStyle = std::make_unique<RuleSet>().release();
     // There are no media-specific rules in the simple default style.
     defaultPrintStyle = defaultStyle;
-    defaultQuirksStyle = RuleSet::create().leakPtr();
+    defaultQuirksStyle = std::make_unique<RuleSet>().release();
 
     simpleDefaultStyleSheet = parseUASheet(simpleUserAgentStyleSheet, strlen(simpleUserAgentStyleSheet));
-    defaultStyle->addRulesFromSheet(simpleDefaultStyleSheet, screenEval());
-
+    defaultStyle->addRulesFromSheet(*simpleDefaultStyleSheet, screenEval());
+    ++defaultStyleVersion;
     // No need to initialize quirks sheet yet as there are no quirk rules for elements allowed in simple default style.
 }
 
-RuleSet* CSSDefaultStyleSheets::viewSourceStyle()
-{
-    if (!defaultViewSourceStyle) {
-        static StyleSheetContents* viewSourceStyleSheet = parseUASheet(sourceUserAgentStyleSheet, sizeof(sourceUserAgentStyleSheet));
-        defaultViewSourceStyle = RuleSet::create().leakPtr();
-        defaultViewSourceStyle->addRulesFromSheet(viewSourceStyleSheet, screenEval());
-    }
-    return defaultViewSourceStyle;
-}
-
-
-void CSSDefaultStyleSheets::ensureDefaultStyleSheetsForElement(Element* element, bool& changedDefaultStyle)
+void CSSDefaultStyleSheets::ensureDefaultStyleSheetsForElement(const Element& element)
 {
     if (simpleDefaultStyleSheet && !elementCanUseSimpleDefaultStyle(element)) {
         loadFullDefaultStyle();
-        changedDefaultStyle = true;
+        ++defaultStyleVersion;
     }
 
-#if ENABLE(SVG)
-    if (element->isSVGElement() && !svgStyleSheet) {
-        // SVG rules.
-        svgStyleSheet = parseUASheet(svgUserAgentStyleSheet, sizeof(svgUserAgentStyleSheet));
-        defaultStyle->addRulesFromSheet(svgStyleSheet, screenEval());
-        defaultPrintStyle->addRulesFromSheet(svgStyleSheet, printEval());
-        changedDefaultStyle = true;
+    if (is<HTMLElement>(element)) {
+        if (is<HTMLObjectElement>(element) || is<HTMLEmbedElement>(element)) {
+            if (!plugInsStyleSheet) {
+                String plugInsRules = RenderTheme::themeForPage(element.document().page())->extraPlugInsStyleSheet() + element.document().page()->chrome().client().plugInExtraStyleSheet();
+                if (plugInsRules.isEmpty())
+                    plugInsRules = String(plugInsUserAgentStyleSheet, sizeof(plugInsUserAgentStyleSheet));
+                plugInsStyleSheet = parseUASheet(plugInsRules);
+                defaultStyle->addRulesFromSheet(*plugInsStyleSheet, screenEval());
+                ++defaultStyleVersion;
+            }
+        }
+#if ENABLE(VIDEO)
+        else if (is<HTMLMediaElement>(element)) {
+            if (!mediaControlsStyleSheet) {
+                String mediaRules = RenderTheme::themeForPage(element.document().page())->mediaControlsStyleSheet();
+                if (mediaRules.isEmpty())
+                    mediaRules = String(mediaControlsUserAgentStyleSheet, sizeof(mediaControlsUserAgentStyleSheet)) + RenderTheme::themeForPage(element.document().page())->extraMediaControlsStyleSheet();
+                mediaControlsStyleSheet = parseUASheet(mediaRules);
+                defaultStyle->addRulesFromSheet(*mediaControlsStyleSheet, screenEval());
+                defaultPrintStyle->addRulesFromSheet(*mediaControlsStyleSheet, printEval());
+                ++defaultStyleVersion;
+            }
+        }
+#endif // ENABLE(VIDEO)
+#if ENABLE(SERVICE_CONTROLS)
+        else if (is<HTMLDivElement>(element) && element.isImageControlsRootElement()) {
+            if (!imageControlsStyleSheet) {
+                String imageControlsRules = RenderTheme::themeForPage(element.document().page())->imageControlsStyleSheet();
+                imageControlsStyleSheet = parseUASheet(imageControlsRules);
+                defaultStyle->addRulesFromSheet(*imageControlsStyleSheet, screenEval());
+                defaultPrintStyle->addRulesFromSheet(*imageControlsStyleSheet, printEval());
+                ++defaultStyleVersion;
+            }
+        }
+#endif // ENABLE(SERVICE_CONTROLS)
+    } else if (is<SVGElement>(element)) {
+        if (!svgStyleSheet) {
+            // SVG rules.
+            svgStyleSheet = parseUASheet(svgUserAgentStyleSheet, sizeof(svgUserAgentStyleSheet));
+            defaultStyle->addRulesFromSheet(*svgStyleSheet, screenEval());
+            defaultPrintStyle->addRulesFromSheet(*svgStyleSheet, printEval());
+            ++defaultStyleVersion;
+        }
     }
-#endif
-
 #if ENABLE(MATHML)
-    if (element->isMathMLElement() && !mathMLStyleSheet) {
-        // MathML rules.
-        mathMLStyleSheet = parseUASheet(mathmlUserAgentStyleSheet, sizeof(mathmlUserAgentStyleSheet));
-        defaultStyle->addRulesFromSheet(mathMLStyleSheet, screenEval());
-        defaultPrintStyle->addRulesFromSheet(mathMLStyleSheet, printEval());
-        changedDefaultStyle = true;
-    }
-#endif
-
-#if ENABLE(VIDEO)
-    if (!mediaControlsStyleSheet && (element->hasTagName(videoTag) || isHTMLAudioElement(element))) {
-        String mediaRules = RenderTheme::themeForPage(element->document().page())->mediaControlsStyleSheet();
-        if (mediaRules.isEmpty())
-            mediaRules = String(mediaControlsUserAgentStyleSheet, sizeof(mediaControlsUserAgentStyleSheet)) + RenderTheme::themeForPage(element->document().page())->extraMediaControlsStyleSheet();
-        mediaControlsStyleSheet = parseUASheet(mediaRules);
-        defaultStyle->addRulesFromSheet(mediaControlsStyleSheet, screenEval());
-        defaultPrintStyle->addRulesFromSheet(mediaControlsStyleSheet, printEval());
-        changedDefaultStyle = true;
+    else if (is<MathMLElement>(element)) {
+        if (!mathMLStyleSheet) {
+            // MathML rules.
+            mathMLStyleSheet = parseUASheet(mathmlUserAgentStyleSheet, sizeof(mathmlUserAgentStyleSheet));
+            defaultStyle->addRulesFromSheet(*mathMLStyleSheet, screenEval());
+            defaultPrintStyle->addRulesFromSheet(*mathMLStyleSheet, printEval());
+            ++defaultStyleVersion;
+        }
     }
-#endif
+#endif // ENABLE(MATHML)
 
 #if ENABLE(FULLSCREEN_API)
-    if (!fullscreenStyleSheet && element->document().webkitIsFullScreen()) {
+    if (!fullscreenStyleSheet && element.document().webkitIsFullScreen()) {
         String fullscreenRules = String(fullscreenUserAgentStyleSheet, sizeof(fullscreenUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraFullScreenStyleSheet();
         fullscreenStyleSheet = parseUASheet(fullscreenRules);
-        defaultStyle->addRulesFromSheet(fullscreenStyleSheet, screenEval());
-        defaultQuirksStyle->addRulesFromSheet(fullscreenStyleSheet, screenEval());
-        changedDefaultStyle = true;
-    }
-#endif
-
-    if (!plugInsStyleSheet && (element->hasTagName(objectTag) || element->hasTagName(embedTag))) {
-        String plugInsRules = RenderTheme::themeForPage(element->document().page())->extraPlugInsStyleSheet() + element->document().page()->chrome().client().plugInExtraStyleSheet();
-        if (plugInsRules.isEmpty())
-            plugInsRules = String(plugInsUserAgentStyleSheet, sizeof(plugInsUserAgentStyleSheet));
-        plugInsStyleSheet = parseUASheet(plugInsRules);
-        defaultStyle->addRulesFromSheet(plugInsStyleSheet, screenEval());
-        changedDefaultStyle = true;
+        defaultStyle->addRulesFromSheet(*fullscreenStyleSheet, screenEval());
+        defaultQuirksStyle->addRulesFromSheet(*fullscreenStyleSheet, screenEval());
+        ++defaultStyleVersion;
     }
+#endif // ENABLE(FULLSCREEN_API)
 
     ASSERT(defaultStyle->features().idsInRules.isEmpty());
     ASSERT(mathMLStyleSheet || defaultStyle->features().siblingRules.isEmpty());