void CSSDefaultStyleSheets::loadFullDefaultStyle()
{
if (simpleDefaultStyleSheet) {
ASSERT(defaultStyle);
ASSERT(defaultPrintStyle == defaultStyle);
delete defaultStyle;
simpleDefaultStyleSheet->deref();
defaultStyle = RuleSet::create().leakPtr();
defaultPrintStyle = RuleSet::create().leakPtr();
simpleDefaultStyleSheet = 0;
} else {
ASSERT(!defaultStyle);
defaultStyle = RuleSet::create().leakPtr();
defaultPrintStyle = RuleSet::create().leakPtr();
defaultQuirksStyle = RuleSet::create().leakPtr();
}
// Strict-mode rules.
String defaultRules = String(htmlUserAgentStyleSheet, sizeof(htmlUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraDefaultStyleSheet();
defaultStyleSheet = parseUASheet(defaultRules);
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());
}
void CSSDefaultStyleSheets::loadDefaultStyle()
{
ASSERT(!defaultStyle);
defaultStyle = RuleSet::create().leakPtr();
defaultViewportStyle = RuleSet::create().leakPtr();
defaultPrintStyle = RuleSet::create().leakPtr();
defaultQuirksStyle = RuleSet::create().leakPtr();
// Strict-mode rules.
String defaultRules = String(htmlUserAgentStyleSheet, sizeof(htmlUserAgentStyleSheet)) + RenderTheme::theme().extraDefaultStyleSheet();
defaultStyleSheet = parseUASheet(defaultRules);
defaultStyle->addRulesFromSheet(defaultStyleSheet, screenEval());
#if OS(ANDROID)
String viewportRules(viewportAndroidUserAgentStyleSheet, sizeof(viewportAndroidUserAgentStyleSheet));
#else
String viewportRules;
#endif
viewportStyleSheet = parseUASheet(viewportRules);
defaultViewportStyle->addRulesFromSheet(viewportStyleSheet, screenEval());
defaultPrintStyle->addRulesFromSheet(defaultStyleSheet, printEval());
// Quirks-mode rules.
String quirksRules = String(quirksUserAgentStyleSheet, sizeof(quirksUserAgentStyleSheet)) + RenderTheme::theme().extraQuirksStyleSheet();
quirksStyleSheet = parseUASheet(quirksRules);
defaultQuirksStyle->addRulesFromSheet(quirksStyleSheet, screenEval());
}
void CSSDefaultStyleSheets::ensureDefaultStyleSheetsForElement(Element* element, bool& changedDefaultStyle)
{
if (simpleDefaultStyleSheet && !elementCanUseSimpleDefaultStyle(element)) {
loadFullDefaultStyle();
changedDefaultStyle = true;
}
// FIXME: We should assert that the sheet only styles SVG elements.
if (element->isSVGElement() && !svgStyleSheet) {
svgStyleSheet = parseUASheet(svgUserAgentStyleSheet, sizeof(svgUserAgentStyleSheet));
defaultStyle->addRulesFromSheet(svgStyleSheet, screenEval());
defaultPrintStyle->addRulesFromSheet(svgStyleSheet, printEval());
changedDefaultStyle = true;
}
// FIXME: We should assert that this sheet only contains rules for <video> and <audio>.
if (!mediaControlsStyleSheet && (isHTMLVideoElement(element) || element->hasTagName(audioTag))) {
String mediaRules = String(mediaControlsUserAgentStyleSheet, sizeof(mediaControlsUserAgentStyleSheet)) + RenderTheme::themeForPage(element->document()->page())->extraMediaControlsStyleSheet();
mediaControlsStyleSheet = parseUASheet(mediaRules);
defaultStyle->addRulesFromSheet(mediaControlsStyleSheet, screenEval());
defaultPrintStyle->addRulesFromSheet(mediaControlsStyleSheet, printEval());
changedDefaultStyle = true;
}
if (!fullscreenStyleSheet && FullscreenElementStack::isFullScreen(element->document())) {
String fullscreenRules = String(fullscreenUserAgentStyleSheet, sizeof(fullscreenUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraFullScreenStyleSheet();
fullscreenStyleSheet = parseUASheet(fullscreenRules);
defaultStyle->addRulesFromSheet(fullscreenStyleSheet, screenEval());
defaultQuirksStyle->addRulesFromSheet(fullscreenStyleSheet, screenEval());
changedDefaultStyle = true;
}
ASSERT(defaultStyle->features().idsInRules.isEmpty());
ASSERT(mathMLStyleSheet || defaultStyle->features().siblingRules.isEmpty());
}
void StyleElement::createSheet(Element* e, const String& text)
{
ASSERT(e);
ASSERT(e->inDocument());
Document& document = e->document();
if (m_sheet)
clearSheet(e);
// If type is empty or CSS, this is a CSS style sheet.
const AtomicString& type = this->type();
if (isCSS(e, type)) {
RefPtr<MediaQuerySet> mediaQueries = MediaQuerySet::create(media());
MediaQueryEvaluator screenEval("screen", true);
MediaQueryEvaluator printEval("print", true);
if (screenEval.eval(mediaQueries.get()) || printEval.eval(mediaQueries.get())) {
m_loading = true;
TextPosition startPosition = m_startPosition == TextPosition::belowRangePosition() ? TextPosition::minimumPosition() : m_startPosition;
m_sheet = document.styleEngine()->createSheet(e, text, startPosition, m_createdByParser);
m_sheet->setMediaQueries(mediaQueries.release());
m_loading = false;
}
}
document.styleResolverMayHaveChanged();
}
void SVGStyleElement::childrenChanged()
{
SVGElement::childrenChanged();
if(m_sheet)
m_sheet = 0;
m_loading = false;
MediaQueryEvaluator screenEval("screen", true);
MediaQueryEvaluator printEval("print", true);
RefPtr<MediaList> mediaList = new MediaList((CSSStyleSheet*)0, media());
if ((type().isEmpty() || type() == "text/css") && (screenEval.eval(mediaList.get()) || printEval.eval(mediaList.get()))) {
ownerDocument()->addPendingSheet();
m_loading = true;
m_sheet = new CSSStyleSheet(this);
m_sheet->parseString(textContent()); // SVG css is always parsed in strict mode
m_sheet->setMedia(mediaList.get());
m_loading = false;
}
if(!isLoading() && m_sheet)
document()->stylesheetLoaded();
}
RuleSet* CSSDefaultStyleSheets::defaultViewSourceStyle()
{
if (!m_defaultViewSourceStyle) {
m_defaultViewSourceStyle = RuleSet::create();
// Loaded stylesheet is leaked on purpose.
RefPtrWillBeRawPtr<StyleSheetContents> stylesheet = parseUASheet(sourceUserAgentStyleSheet, sizeof(sourceUserAgentStyleSheet));
m_defaultViewSourceStyle->addRulesFromSheet(stylesheet.release().leakRef(), screenEval());
}
return m_defaultViewSourceStyle.get();
}
void CSSDefaultStyleSheets::ensureDefaultStyleSheetsForElement(Element* element, bool& changedDefaultStyle)
{
// FIXME: We should assert that the sheet only styles SVG elements.
if (element->isSVGElement() && !m_svgStyleSheet) {
m_svgStyleSheet = parseUASheet(svgUserAgentStyleSheet, sizeof(svgUserAgentStyleSheet));
m_defaultStyle->addRulesFromSheet(svgStyleSheet(), screenEval());
m_defaultPrintStyle->addRulesFromSheet(svgStyleSheet(), printEval());
changedDefaultStyle = true;
}
// FIXME: We should assert that the sheet only styles MathML elements.
if (element->namespaceURI() == MathMLNames::mathmlNamespaceURI
&& !m_mathmlStyleSheet) {
m_mathmlStyleSheet = parseUASheet(mathmlUserAgentStyleSheet,
sizeof(mathmlUserAgentStyleSheet));
m_defaultStyle->addRulesFromSheet(mathmlStyleSheet(), screenEval());
m_defaultPrintStyle->addRulesFromSheet(mathmlStyleSheet(), printEval());
changedDefaultStyle = true;
}
// FIXME: We should assert that this sheet only contains rules for <video> and <audio>.
if (!m_mediaControlsStyleSheet && (isHTMLVideoElement(*element) || isHTMLAudioElement(*element))) {
String mediaRules = String(mediaControlsUserAgentStyleSheet, sizeof(mediaControlsUserAgentStyleSheet)) + RenderTheme::theme().extraMediaControlsStyleSheet();
m_mediaControlsStyleSheet = parseUASheet(mediaRules);
m_defaultStyle->addRulesFromSheet(mediaControlsStyleSheet(), screenEval());
m_defaultPrintStyle->addRulesFromSheet(mediaControlsStyleSheet(), printEval());
changedDefaultStyle = true;
}
// FIXME: This only works because we Force recalc the entire document so the new sheet
// is loaded for <html> and the correct styles apply to everyone.
if (!m_fullscreenStyleSheet && FullscreenElementStack::isFullScreen(element->document())) {
String fullscreenRules = String(fullscreenUserAgentStyleSheet, sizeof(fullscreenUserAgentStyleSheet)) + RenderTheme::theme().extraFullScreenStyleSheet();
m_fullscreenStyleSheet = parseUASheet(fullscreenRules);
m_defaultStyle->addRulesFromSheet(fullscreenStyleSheet(), screenEval());
m_defaultQuirksStyle->addRulesFromSheet(fullscreenStyleSheet(), screenEval());
changedDefaultStyle = true;
}
ASSERT(!m_defaultStyle->features().hasIdsInSelectors());
ASSERT(m_defaultStyle->features().siblingRules.isEmpty());
}
void CSSDefaultStyleSheets::ensureDefaultStyleSheetsForElement(Element* element, bool& changedDefaultStyle)
{
// FIXME: We should assert that the sheet only styles SVG elements.
if (element->isSVGElement() && !svgStyleSheet) {
svgStyleSheet = parseUASheet(svgUserAgentStyleSheet, sizeof(svgUserAgentStyleSheet));
defaultStyle->addRulesFromSheet(svgStyleSheet, screenEval());
defaultPrintStyle->addRulesFromSheet(svgStyleSheet, printEval());
changedDefaultStyle = true;
}
#if ENABLE(WML)
// FIXME: We should assert that the sheet only styles WML elements.
if (element->isWMLElement() && !wmlStyleSheet) {
wmlStyleSheet = parseUASheet(wmlUserAgentStyleSheet, sizeof(wmlUserAgentStyleSheet));
defaultStyle->addRulesFromSheet(wmlStyleSheet, screenEval());
defaultPrintStyle->addRulesFromSheet(wmlStyleSheet, printEval());
changedDefaultStyle = true;
}
#endif
// FIXME: We should assert that this sheet only contains rules for <video> and <audio>.
if (!mediaControlsStyleSheet && (isHTMLVideoElement(element) || element->hasTagName(audioTag))) {
String mediaRules = String(mediaControlsUserAgentStyleSheet, sizeof(mediaControlsUserAgentStyleSheet)) + RenderTheme::theme().extraMediaControlsStyleSheet();
mediaControlsStyleSheet = parseUASheet(mediaRules);
defaultStyle->addRulesFromSheet(mediaControlsStyleSheet, screenEval());
defaultPrintStyle->addRulesFromSheet(mediaControlsStyleSheet, printEval());
changedDefaultStyle = true;
}
// FIXME: This only works because we Force recalc the entire document so the new sheet
// is loaded for <html> and the correct styles apply to everyone.
if (!fullscreenStyleSheet && FullscreenElementStack::isFullScreen(&element->document())) {
String fullscreenRules = String(fullscreenUserAgentStyleSheet, sizeof(fullscreenUserAgentStyleSheet)) + RenderTheme::theme().extraFullScreenStyleSheet();
fullscreenStyleSheet = parseUASheet(fullscreenRules);
defaultStyle->addRulesFromSheet(fullscreenStyleSheet, screenEval());
defaultQuirksStyle->addRulesFromSheet(fullscreenStyleSheet, screenEval());
changedDefaultStyle = true;
}
ASSERT(defaultStyle->features().idsInRules.isEmpty());
ASSERT(defaultStyle->features().siblingRules.isEmpty());
}
CSSDefaultStyleSheets::CSSDefaultStyleSheets()
: m_defaultStyle(nullptr)
, m_defaultViewportStyle(nullptr)
, m_defaultQuirksStyle(nullptr)
, m_defaultPrintStyle(nullptr)
, m_defaultViewSourceStyle(nullptr)
, m_defaultXHTMLMobileProfileStyle(nullptr)
, m_defaultStyleSheet(nullptr)
, m_viewportStyleSheet(nullptr)
, m_quirksStyleSheet(nullptr)
, m_svgStyleSheet(nullptr)
, m_mathmlStyleSheet(nullptr)
, m_mediaControlsStyleSheet(nullptr)
, m_fullscreenStyleSheet(nullptr)
{
m_defaultStyle = RuleSet::create();
m_defaultViewportStyle = RuleSet::create();
m_defaultPrintStyle = RuleSet::create();
m_defaultQuirksStyle = RuleSet::create();
// Strict-mode rules.
String defaultRules = String(htmlUserAgentStyleSheet, sizeof(htmlUserAgentStyleSheet)) + RenderTheme::theme().extraDefaultStyleSheet();
m_defaultStyleSheet = parseUASheet(defaultRules);
m_defaultStyle->addRulesFromSheet(defaultStyleSheet(), screenEval());
#if OS(ANDROID)
String viewportRules(viewportAndroidUserAgentStyleSheet, sizeof(viewportAndroidUserAgentStyleSheet));
#else
String viewportRules;
#endif
m_viewportStyleSheet = parseUASheet(viewportRules);
m_defaultViewportStyle->addRulesFromSheet(viewportStyleSheet(), screenEval());
m_defaultPrintStyle->addRulesFromSheet(defaultStyleSheet(), printEval());
// Quirks-mode rules.
String quirksRules = String(quirksUserAgentStyleSheet, sizeof(quirksUserAgentStyleSheet)) + RenderTheme::theme().extraQuirksStyleSheet();
m_quirksStyleSheet = parseUASheet(quirksRules);
m_defaultQuirksStyle->addRulesFromSheet(quirksStyleSheet(), screenEval());
}
void CSSDefaultStyleSheets::loadSimpleDefaultStyle()
{
ASSERT(!defaultStyle);
ASSERT(!simpleDefaultStyleSheet);
defaultStyle = RuleSet::create().leakPtr();
// There are no media-specific rules in the simple default style.
defaultPrintStyle = defaultStyle;
defaultQuirksStyle = RuleSet::create().leakPtr();
simpleDefaultStyleSheet = parseUASheet(simpleUserAgentStyleSheet, strlen(simpleUserAgentStyleSheet));
defaultStyle->addRulesFromSheet(simpleDefaultStyleSheet, screenEval());
// No need to initialize quirks sheet yet as there are no quirk rules for elements allowed in simple default style.
}
StyleElement::ProcessingResult StyleElement::createSheet(Element& element,
const String& text) {
DCHECK(element.isConnected());
Document& document = element.document();
const ContentSecurityPolicy* csp = document.contentSecurityPolicy();
bool passesContentSecurityPolicyChecks =
shouldBypassMainWorldCSP(element) ||
csp->allowStyleWithHash(text, ContentSecurityPolicy::InlineType::Block) ||
csp->allowInlineStyle(&element, document.url(),
element.fastGetAttribute(HTMLNames::nonceAttr),
m_startPosition.m_line, text);
// Clearing the current sheet may remove the cache entry so create the new
// sheet first
CSSStyleSheet* newSheet = nullptr;
// If type is empty or CSS, this is a CSS style sheet.
const AtomicString& type = this->type();
if (isCSS(element, type) && passesContentSecurityPolicyChecks) {
MediaQuerySet* mediaQueries = MediaQuerySet::create(media());
MediaQueryEvaluator screenEval("screen");
MediaQueryEvaluator printEval("print");
if (screenEval.eval(mediaQueries) || printEval.eval(mediaQueries)) {
m_loading = true;
TextPosition startPosition =
m_startPosition == TextPosition::belowRangePosition()
? TextPosition::minimumPosition()
: m_startPosition;
newSheet = document.styleEngine().createSheet(
element, text, startPosition, m_styleEngineContext);
newSheet->setMediaQueries(mediaQueries);
m_loading = false;
}
}
if (m_sheet)
clearSheet(element);
m_sheet = newSheet;
if (m_sheet)
m_sheet->contents()->checkLoaded();
return passesContentSecurityPolicyChecks ? ProcessingSuccessful
: ProcessingFatalError;
}
bool StyleMedia::matchMedium(const String& query) const
{
if (!m_frame)
return false;
Document* document = m_frame->document();
ASSERT(document);
Element* documentElement = document->documentElement();
if (!documentElement)
return false;
RefPtrWillBeRawPtr<MediaQuerySet> media = MediaQuerySet::create();
if (!media->set(query))
return false;
MediaQueryEvaluator screenEval(m_frame);
return screenEval.eval(media.get());
}
void InlineStyleSheetOwner::createSheet(Element& element, const String& text)
{
ASSERT(element.inDocument());
Document& document = element.document();
if (m_sheet) {
if (m_sheet->isLoading())
document.authorStyleSheets().removePendingSheet();
clearSheet();
}
if (!isValidCSSContentType(element, m_contentType))
return;
ASSERT(document.contentSecurityPolicy());
const ContentSecurityPolicy& contentSecurityPolicy = *document.contentSecurityPolicy();
bool hasKnownNonce = contentSecurityPolicy.allowStyleWithNonce(element.fastGetAttribute(HTMLNames::nonceAttr), element.isInUserAgentShadowTree());
if (!contentSecurityPolicy.allowInlineStyle(document.url(), m_startTextPosition.m_line, text, hasKnownNonce))
return;
RefPtr<MediaQuerySet> mediaQueries;
if (element.isHTMLElement())
mediaQueries = MediaQuerySet::createAllowingDescriptionSyntax(m_media);
else
mediaQueries = MediaQuerySet::create(m_media);
MediaQueryEvaluator screenEval(ASCIILiteral("screen"), true);
MediaQueryEvaluator printEval(ASCIILiteral("print"), true);
if (!screenEval.evaluate(*mediaQueries) && !printEval.evaluate(*mediaQueries))
return;
authorStyleSheetsForElement(element).addPendingSheet();
m_loading = true;
m_sheet = CSSStyleSheet::createInline(element, URL(), m_startTextPosition, document.encoding());
m_sheet->setMediaQueries(mediaQueries.releaseNonNull());
m_sheet->setTitle(element.title());
m_sheet->contents().parseStringAtPosition(text, m_startTextPosition, m_isParsingChildren);
m_loading = false;
if (m_sheet)
m_sheet->contents().checkLoaded();
}
bool StyleMedia::matchMedium(const String& query) const
{
if (!m_frame)
return false;
Document* document = m_frame->document();
ASSERT(document);
Element* documentElement = document->documentElement();
if (!documentElement)
return false;
auto rootStyle = document->ensureStyleResolver().styleForElement(*documentElement, document->renderStyle(), MatchOnlyUserAgentRules).renderStyle;
RefPtr<MediaQuerySet> media = MediaQuerySet::create();
if (!media->parse(query))
return false;
MediaQueryEvaluator screenEval(type(), m_frame, rootStyle.ptr());
return screenEval.eval(media.get());
}
void InlineStyleSheetOwner::createSheet(Element* element, const String& text)
{
ASSERT(element);
ASSERT(element->inDocument());
Document& document = element->document();
if (m_sheet) {
if (m_sheet->isLoading())
document.styleSheetCollection()->removePendingSheet();
clearSheet();
}
if (!isValidCSSContentType(element, m_contentType))
return;
if (!document.contentSecurityPolicy()->allowInlineStyle(document.url(), m_startLineNumber))
return;
RefPtr<MediaQuerySet> mediaQueries;
if (element->isHTMLElement())
mediaQueries = MediaQuerySet::createAllowingDescriptionSyntax(m_media);
else
mediaQueries = MediaQuerySet::create(m_media);
MediaQueryEvaluator screenEval(ASCIILiteral("screen"), true);
MediaQueryEvaluator printEval(ASCIILiteral("print"), true);
if (!screenEval.eval(mediaQueries.get()) && !printEval.eval(mediaQueries.get()))
return;
document.styleSheetCollection()->addPendingSheet();
m_loading = true;
m_sheet = CSSStyleSheet::createInline(element, KURL(), document.inputEncoding());
m_sheet->setMediaQueries(mediaQueries.release());
m_sheet->setTitle(element->title());
m_sheet->contents()->parseStringAtLine(text, m_startLineNumber.zeroBasedInt(), m_isParsingChildren);
m_loading = false;
if (m_sheet)
m_sheet->contents()->checkLoaded();
}
void StyleElement::createSheet(Element* e, const String& text)
{
ASSERT(e);
ASSERT(e->inDocument());
Document& document = e->document();
if (m_sheet) {
if (m_sheet->isLoading())
document.styleEngine()->removePendingSheet(e);
clearSheet();
}
// If type is empty or CSS, this is a CSS style sheet.
const AtomicString& type = this->type();
bool passesContentSecurityPolicyChecks = document.contentSecurityPolicy()->allowStyleNonce(e->fastGetAttribute(HTMLNames::nonceAttr)) || document.contentSecurityPolicy()->allowInlineStyle(e->document().url(), m_startPosition.m_line);
if (isCSS(e, type) && passesContentSecurityPolicyChecks) {
RefPtr<MediaQuerySet> mediaQueries = MediaQuerySet::create(media());
MediaQueryEvaluator screenEval("screen", true);
MediaQueryEvaluator printEval("print", true);
if (screenEval.eval(mediaQueries.get()) || printEval.eval(mediaQueries.get())) {
document.styleEngine()->addPendingSheet();
m_loading = true;
TextPosition startPosition = m_startPosition == TextPosition::belowRangePosition() ? TextPosition::minimumPosition() : m_startPosition;
m_sheet = CSSStyleSheet::createInline(e, KURL(), startPosition, document.inputEncoding());
m_sheet->setMediaQueries(mediaQueries.release());
m_sheet->setTitle(e->title());
m_sheet->contents()->parseStringAtPosition(text, startPosition, m_createdByParser);
m_loading = false;
}
}
if (m_sheet)
m_sheet->contents()->checkLoaded();
}
RuleSet* CSSDefaultStyleSheets::xhtmlMobileProfileStyle()
{
if (!defaultXHTMLMobileProfileStyle) {
defaultXHTMLMobileProfileStyle = RuleSet::create().leakPtr();
defaultXHTMLMobileProfileStyle->addRulesFromSheet(parseUASheet(xhtmlmpUserAgentStyleSheet, sizeof(xhtmlmpUserAgentStyleSheet)), screenEval());
}
return defaultXHTMLMobileProfileStyle;
}
RuleSet* CSSDefaultStyleSheets::viewSourceStyle()
{
if (!defaultViewSourceStyle) {
defaultViewSourceStyle = RuleSet::create().leakPtr();
defaultViewSourceStyle->addRulesFromSheet(parseUASheet(sourceUserAgentStyleSheet, sizeof(sourceUserAgentStyleSheet)), screenEval());
}
return defaultViewSourceStyle;
}
void StyleElement::createSheet(Element* e, int startLineNumber, const String& text)
{
ASSERT(e);
ASSERT(e->inDocument());
Document* document = e->document();
if (m_sheet) {
if (m_sheet->isLoading())
document->removePendingSheet();
m_sheet = 0;
}
// If type is empty or CSS, this is a CSS style sheet.
const AtomicString& type = this->type();
if (document->contentSecurityPolicy()->allowInlineStyle() && isCSS(e, type)) {
RefPtr<MediaList> mediaList = MediaList::create(media(), e->isHTMLElement());
MediaQueryEvaluator screenEval("screen", true);
MediaQueryEvaluator printEval("print", true);
if (screenEval.eval(mediaList.get()) || printEval.eval(mediaList.get())) {
document->addPendingSheet();
m_loading = true;
m_sheet = CSSStyleSheet::create(e, String(), KURL(), document->inputEncoding());
m_sheet->parseStringAtLine(text, !document->inQuirksMode(), startLineNumber);
m_sheet->setMedia(mediaList.get());
m_sheet->setTitle(e->title());
m_loading = false;
}
}
if (m_sheet)
m_sheet->checkLoaded();
}
void StyleElement::createSheet(Element* e, const String& text)
{
Document* document = e->document();
if (m_sheet) {
if (static_cast<CSSStyleSheet*>(m_sheet.get())->isLoading())
document->removePendingSheet();
m_sheet = 0;
}
// If type is empty or CSS, this is a CSS style sheet.
const AtomicString& type = this->type();
if (type.isEmpty() || (e->isHTMLElement() ? equalIgnoringCase(type, "text/css") : (type == "text/css"))) {
RefPtr<MediaList> mediaList = MediaList::create(media(), e->isHTMLElement());
MediaQueryEvaluator screenEval("screen", true);
MediaQueryEvaluator printEval("print", true);
if (screenEval.eval(mediaList.get()) || printEval.eval(mediaList.get())) {
document->addPendingSheet();
setLoading(true);
m_sheet = CSSStyleSheet::create(e, String(), document->inputEncoding());
m_sheet->parseString(text, !document->inCompatMode());
m_sheet->setMedia(mediaList.get());
m_sheet->setTitle(e->title());
setLoading(false);
}
}
if (m_sheet)
m_sheet->checkLoaded();
}
