Web Inspector: NMI: move WebCore specific code to separate header
[WebKit-https.git] / Source / WebCore / css / StyleSheetContents.cpp
1 /*
2  * (C) 1999-2003 Lars Knoll (knoll@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 "StyleSheetContents.h"
23
24 #include "CSSImportRule.h"
25 #include "CSSParser.h"
26 #include "CSSStyleSheet.h"
27 #include "CachedCSSStyleSheet.h"
28 #include "Document.h"
29 #include "Node.h"
30 #include "SecurityOrigin.h"
31 #include "StylePropertySet.h"
32 #include "StyleRule.h"
33 #include "StyleRuleImport.h"
34 #include "WebCoreMemoryInstrumentation.h"
35 #include <wtf/Deque.h>
36
37 namespace WebCore {
38
39 // Rough size estimate for the memory cache.
40 unsigned StyleSheetContents::estimatedSizeInBytes() const
41 {
42     // Note that this does not take into account size of the strings hanging from various objects. 
43     // The assumption is that nearly all of of them are atomic and would exist anyway.
44     unsigned size = sizeof(*this);
45
46     // FIXME: This ignores the children of media and region rules.
47     // Most rules are StyleRules.
48     size += ruleCount() * StyleRule::averageSizeInBytes();
49
50     for (unsigned i = 0; i < m_importRules.size(); ++i) {
51         if (StyleSheetContents* sheet = m_importRules[i]->styleSheet())
52             size += sheet->estimatedSizeInBytes();
53     }
54     return size;
55 }
56
57 StyleSheetContents::StyleSheetContents(const String& originalURL, const CSSParserContext& context)
58     : m_originalURL(originalURL)
59     , m_loadCompleted(false)
60     , m_hasSyntacticallyValidCSSHeader(true)
61     , m_didLoadErrorOccur(false)
62     , m_usesRemUnits(false)
63     , m_isMutable(false)
64     , m_isInMemoryCache(false)
65     , m_parserContext(context)
66 {
67 }
68
69 StyleSheetContents::StyleSheetContents(const StyleSheetContents& o)
70     : RefCounted<StyleSheetContents>()
71     , m_originalURL(o.m_originalURL)
72     , m_encodingFromCharsetRule(o.m_encodingFromCharsetRule)
73     , m_importRules(o.m_importRules.size())
74     , m_childRules(o.m_childRules.size())
75     , m_namespaces(o.m_namespaces)
76     , m_loadCompleted(true)
77     , m_isUserStyleSheet(o.m_isUserStyleSheet)
78     , m_hasSyntacticallyValidCSSHeader(o.m_hasSyntacticallyValidCSSHeader)
79     , m_didLoadErrorOccur(false)
80     , m_usesRemUnits(o.m_usesRemUnits)
81     , m_isMutable(false)
82     , m_isInMemoryCache(false)
83     , m_parserContext(o.m_parserContext)
84 {
85     ASSERT(o.isCacheable());
86
87     // FIXME: Copy import rules.
88     ASSERT(o.m_importRules.isEmpty());
89
90     for (unsigned i = 0; i < m_childRules.size(); ++i)
91         m_childRules[i] = o.m_childRules[i]->copy();
92 }
93
94 StyleSheetContents::~StyleSheetContents()
95 {
96     clearRules();
97 }
98
99 bool StyleSheetContents::isCacheable() const
100 {
101     // FIXME: Support copying import rules.
102     if (!m_importRules.isEmpty())
103         return false;
104     // This would require dealing with multiple clients for load callbacks.
105     if (!m_loadCompleted)
106         return false;
107     if (m_didLoadErrorOccur)
108         return false;
109     // It is not the original sheet anymore.
110     if (m_isMutable)
111         return false;
112     // If the header is valid we are not going to need to check the SecurityOrigin.
113     // FIXME: Valid mime type avoids the check too.
114     if (!m_hasSyntacticallyValidCSSHeader)
115         return false;
116     return true;
117 }
118
119 void StyleSheetContents::parserAppendRule(PassRefPtr<StyleRuleBase> rule)
120 {
121     ASSERT(!rule->isCharsetRule());
122     if (rule->isImportRule()) {
123         // Parser enforces that @import rules come before anything else except @charset.
124         ASSERT(m_childRules.isEmpty());
125         m_importRules.append(static_cast<StyleRuleImport*>(rule.get()));
126         return;
127     }
128     m_childRules.append(rule);
129 }
130
131 StyleRuleBase* StyleSheetContents::ruleAt(unsigned index) const
132 {
133     ASSERT(index < ruleCount());
134     
135     unsigned childVectorIndex = index;
136     if (hasCharsetRule()) {
137         if (index == 0)
138             return 0;
139         --childVectorIndex;
140     }
141     if (childVectorIndex < m_importRules.size())
142         return m_importRules[childVectorIndex].get();
143
144     childVectorIndex -= m_importRules.size();
145     return m_childRules[childVectorIndex].get();
146 }
147
148 unsigned StyleSheetContents::ruleCount() const
149 {
150     unsigned result = 0;
151     result += hasCharsetRule() ? 1 : 0;
152     result += m_importRules.size();
153     result += m_childRules.size();
154     return result;
155 }
156
157 void StyleSheetContents::clearCharsetRule()
158 {
159     m_encodingFromCharsetRule = String();
160 }
161
162 void StyleSheetContents::clearRules()
163 {
164     m_importRules.clear();
165     m_childRules.clear();
166     clearCharsetRule();
167 }
168
169 void StyleSheetContents::parserSetEncodingFromCharsetRule(const String& encoding)
170 {
171     // Parser enforces that there is ever only one @charset.
172     ASSERT(m_encodingFromCharsetRule.isNull());
173     m_encodingFromCharsetRule = encoding; 
174 }
175
176 bool StyleSheetContents::wrapperInsertRule(PassRefPtr<StyleRuleBase> rule, unsigned index)
177 {
178     ASSERT(m_isMutable);
179     ASSERT(index <= ruleCount());
180     // Parser::parseRule doesn't currently allow @charset so we don't need to deal with it.
181     ASSERT(!rule->isCharsetRule());
182     
183     unsigned childVectorIndex = index;
184     // m_childRules does not contain @charset which is always in index 0 if it exists.
185     if (hasCharsetRule()) {
186         if (childVectorIndex == 0) {
187             // Nothing can be inserted before @charset.
188             return false;
189         }
190         --childVectorIndex;
191     }
192     
193     if (childVectorIndex < m_importRules.size() || (childVectorIndex == m_importRules.size() && rule->isImportRule())) {
194         // Inserting non-import rule before @import is not allowed.
195         if (!rule->isImportRule())
196             return false;
197         m_importRules.insert(childVectorIndex, static_cast<StyleRuleImport*>(rule.get()));
198         return true;
199     }
200     // Inserting @import rule after a non-import rule is not allowed.
201     if (rule->isImportRule())
202         return false;
203     childVectorIndex -= m_importRules.size();
204  
205     m_childRules.insert(childVectorIndex, rule);
206     return true;
207 }
208
209 void StyleSheetContents::wrapperDeleteRule(unsigned index)
210 {
211     ASSERT(m_isMutable);
212     ASSERT(index < ruleCount());
213
214     unsigned childVectorIndex = index;
215     if (hasCharsetRule()) {
216         if (childVectorIndex == 0) {
217             clearCharsetRule();
218             return;
219         }
220         --childVectorIndex;
221     }
222     if (childVectorIndex < m_importRules.size()) {
223         m_importRules.remove(childVectorIndex);
224         return;
225     }
226     childVectorIndex -= m_importRules.size();
227
228     m_childRules.remove(childVectorIndex);
229 }
230
231 void StyleSheetContents::parserAddNamespace(const AtomicString& prefix, const AtomicString& uri)
232 {
233     if (uri.isNull() || prefix.isNull())
234         return;
235     PrefixNamespaceURIMap::AddResult result = m_namespaces.add(prefix, uri);
236     if (result.isNewEntry)
237         return;
238     result.iterator->second = uri;
239 }
240
241 const AtomicString& StyleSheetContents::determineNamespace(const AtomicString& prefix)
242 {
243     if (prefix.isNull())
244         return nullAtom; // No namespace. If an element/attribute has a namespace, we won't match it.
245     if (prefix == starAtom)
246         return starAtom; // We'll match any namespace.
247     PrefixNamespaceURIMap::const_iterator it = m_namespaces.find(prefix);
248     if (it == m_namespaces.end())
249         return nullAtom;
250     return it->second;
251 }
252
253 void StyleSheetContents::requestImportedStyleSheets(CSSStyleSheet* rootSheet)
254 {
255     ASSERT(!rootSheet->parentStyleSheet());
256     for (unsigned i = 0; i < m_importRules.size(); ++i)
257         m_importRules[i]->requestStyleSheet(rootSheet, parserContext());
258 }
259
260 void StyleSheetContents::parseAuthorStyleSheet(const CachedCSSStyleSheet* cachedStyleSheet, CSSStyleSheet* rootSheet)
261 {
262     if (cachedStyleSheet->errorOccurred()) {
263         m_didLoadErrorOccur = true;
264         return;
265     }
266     Document* ownerDocument = rootSheet->ownerDocument();
267     if (!ownerDocument)
268         return;
269     // Check to see if we should enforce the MIME type of the CSS resource in strict mode.
270     // Running in iWeb 2 is one example of where we don't want to - <rdar://problem/6099748>
271     bool enforceMIMEType = isStrictParserMode(m_parserContext.mode) && m_parserContext.enforcesCSSMIMETypeInNoQuirksMode;
272     bool hasValidMIMEType = false;
273     String sheetText = cachedStyleSheet->sheetText(enforceMIMEType, &hasValidMIMEType);
274
275     CSSParser p(parserContext());
276     p.parseSheet(this, sheetText, 0);
277
278     // If we're loading a stylesheet cross-origin, and the MIME type is not standard, require the CSS
279     // to at least start with a syntactically valid CSS rule.
280     // This prevents an attacker playing games by injecting CSS strings into HTML, XML, JSON, etc. etc.
281     if (!hasValidMIMEType && !hasSyntacticallyValidCSSHeader()) {
282         const SecurityOrigin* securityOrigin = ownerDocument->securityOrigin();
283         bool isCrossOriginCSS = !securityOrigin || !securityOrigin->canRequest(baseURL());
284         if (isCrossOriginCSS) {
285             clearRules();
286             return;
287         }
288     }
289     if (m_parserContext.needsSiteSpecificQuirks && isStrictParserMode(m_parserContext.mode)) {
290         // Work around <https://bugs.webkit.org/show_bug.cgi?id=28350>.
291         DEFINE_STATIC_LOCAL(const String, mediaWikiKHTMLFixesStyleSheet, (ASCIILiteral("/* KHTML fix stylesheet */\n/* work around the horizontal scrollbars */\n#column-content { margin-left: 0; }\n\n")));
292         // There are two variants of KHTMLFixes.css. One is equal to mediaWikiKHTMLFixesStyleSheet,
293         // while the other lacks the second trailing newline.
294         if (baseURL().string().endsWith("/KHTMLFixes.css") && !sheetText.isNull() && mediaWikiKHTMLFixesStyleSheet.startsWith(sheetText)
295             && sheetText.length() >= mediaWikiKHTMLFixesStyleSheet.length() - 1) {
296             clearRules();
297             return;
298         }
299     }
300
301     requestImportedStyleSheets(rootSheet);
302 }
303
304 bool StyleSheetContents::parseString(const String& sheetText)
305 {
306     return parseStringAtLine(sheetText, 0);
307 }
308
309 bool StyleSheetContents::parseStringAtLine(const String& sheetText, int startLineNumber)
310 {
311     CSSParser p(parserContext());
312     p.parseSheet(this, sheetText, startLineNumber);
313
314     if (!m_clients.isEmpty()) {
315         ASSERT(m_clients.size() == 1);
316         requestImportedStyleSheets(m_clients[0]);
317     }
318     return true;
319 }
320
321 bool StyleSheetContents::isLoading() const
322 {
323     for (unsigned i = 0; i < m_importRules.size(); ++i) {
324         if (m_importRules[i]->isLoading())
325             return true;
326     }
327     return false;
328 }
329
330 bool StyleSheetContents::checkImportedSheetLoadCompleted()
331 {
332     for (unsigned i = 0; i < m_importRules.size(); ++i) {
333         StyleRuleImport* importRule = m_importRules[i].get();
334         if (importRule->isLoading())
335             return false;
336         if (importRule->styleSheet() && !importRule->styleSheet()->checkImportedSheetLoadCompleted())
337             return false;
338         if (importRule->hadLoadError())
339             m_didLoadErrorOccur = true;
340     }
341     m_loadCompleted = true;
342     return true;
343 }
344
345 void StyleSheetContents::checkLoadCompleted()
346 {
347     if (m_clients.isEmpty())
348         return;
349     if (!checkImportedSheetLoadCompleted())
350         return;
351
352     RefPtr<StyleSheetContents> protect(this);
353
354     ASSERT(hasOneClient());
355     ASSERT(!m_clients[0]->parentStyleSheet());
356     RefPtr<Node> ownerNode = m_clients[0]->ownerNode();
357     if (!ownerNode)
358         return;
359     
360     m_loadCompleted = ownerNode->sheetLoaded();
361     if (m_loadCompleted)
362         ownerNode->notifyLoadedSheetAndAllCriticalSubresources(m_didLoadErrorOccur);
363 }
364
365 bool StyleSheetContents::getAncestors(const StyleRuleImport* importRule, Vector<const StyleSheetContents*>& result) const
366 {
367     result.append(this);
368     for (unsigned i = 0; i < m_importRules.size(); ++i) {
369         if (m_importRules[i] == importRule)
370             return true;
371     }
372     for (unsigned i = 0; i < m_importRules.size(); ++i) {
373         if (m_importRules[i]->styleSheet() && m_importRules[i]->styleSheet()->getAncestors(importRule, result))
374             return true;
375     }
376     result.removeLast();
377     return false;
378 }
379
380 bool StyleSheetContents::hasImportCycle(const StyleRuleImport* importRule, const KURL& importURL, const KURL& documentBaseURL) const
381 {
382     Vector<const StyleSheetContents*> ancestors;
383     getAncestors(importRule, ancestors);
384
385     KURL parentBaseURL = documentBaseURL;
386     for (unsigned i = 0; i < ancestors.size(); ++i) {
387         if (equalIgnoringFragmentIdentifier(importURL, ancestors[i]->baseURL()))
388             return true;
389         if (equalIgnoringFragmentIdentifier(importURL, KURL(parentBaseURL, ancestors[i]->originalURL())))
390             return true;
391         parentBaseURL = ancestors[i]->baseURL();
392     }
393     return false;
394 }
395
396 KURL StyleSheetContents::completeURL(const String& url) const
397 {
398     return CSSParser::completeURL(m_parserContext, url);
399 }
400
401 void StyleSheetContents::addSubresourceStyleURLs(ListHashSet<KURL>& urls)
402 {
403     Deque<StyleSheetContents*> styleSheetQueue;
404     styleSheetQueue.append(this);
405
406     while (!styleSheetQueue.isEmpty()) {
407         StyleSheetContents* styleSheet = styleSheetQueue.takeFirst();
408         
409         for (unsigned i = 0; i < styleSheet->m_importRules.size(); ++i) {
410             StyleRuleImport* importRule = styleSheet->m_importRules[i].get();
411             if (importRule->styleSheet()) {
412                 styleSheetQueue.append(importRule->styleSheet());
413                 addSubresourceURL(urls, importRule->styleSheet()->baseURL());
414             }
415         }
416         for (unsigned i = 0; i < styleSheet->m_childRules.size(); ++i) {
417             StyleRuleBase* rule = styleSheet->m_childRules[i].get();
418             if (rule->isStyleRule())
419                 static_cast<StyleRule*>(rule)->properties()->addSubresourceStyleURLs(urls, this);
420             else if (rule->isFontFaceRule())
421                 static_cast<StyleRuleFontFace*>(rule)->properties()->addSubresourceStyleURLs(urls, this);
422         }
423     }
424 }
425
426 static bool childRulesHaveFailedOrCanceledSubresources(const Vector<RefPtr<StyleRuleBase> >& rules)
427 {
428     for (unsigned i = 0; i < rules.size(); ++i) {
429         const StyleRuleBase* rule = rules[i].get();
430         switch (rule->type()) {
431         case StyleRuleBase::Style:
432             if (static_cast<const StyleRule*>(rule)->properties()->hasFailedOrCanceledSubresources())
433                 return true;
434             break;
435         case StyleRuleBase::FontFace:
436             if (static_cast<const StyleRuleFontFace*>(rule)->properties()->hasFailedOrCanceledSubresources())
437                 return true;
438             break;
439         case StyleRuleBase::Media:
440             if (childRulesHaveFailedOrCanceledSubresources(static_cast<const StyleRuleMedia*>(rule)->childRules()))
441                 return true;
442             break;
443         case StyleRuleBase::Region:
444             if (childRulesHaveFailedOrCanceledSubresources(static_cast<const StyleRuleRegion*>(rule)->childRules()))
445                 return true;
446             break;
447         case StyleRuleBase::Import:
448             ASSERT_NOT_REACHED();
449         case StyleRuleBase::Page:
450         case StyleRuleBase::Keyframes:
451         case StyleRuleBase::Unknown:
452         case StyleRuleBase::Charset:
453         case StyleRuleBase::Keyframe:
454             break;
455         }
456     }
457     return false;
458 }
459
460 bool StyleSheetContents::hasFailedOrCanceledSubresources() const
461 {
462     ASSERT(isCacheable());
463     return childRulesHaveFailedOrCanceledSubresources(m_childRules);
464 }
465
466 void StyleSheetContents::registerClient(CSSStyleSheet* sheet)
467 {
468     ASSERT(!m_clients.contains(sheet));
469     m_clients.append(sheet);
470 }
471
472 void StyleSheetContents::unregisterClient(CSSStyleSheet* sheet)
473 {
474     size_t position = m_clients.find(sheet);
475     ASSERT(position != notFound);
476     m_clients.remove(position);
477 }
478
479 void StyleSheetContents::addedToMemoryCache()
480 {
481     ASSERT(!m_isInMemoryCache);
482     ASSERT(isCacheable());
483     m_isInMemoryCache = true;
484 }
485
486 void StyleSheetContents::removedFromMemoryCache()
487 {
488     ASSERT(m_isInMemoryCache);
489     ASSERT(isCacheable());
490     m_isInMemoryCache = false;
491 }
492
493 void StyleSheetContents::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
494 {
495     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::CSS);
496     info.addInstrumentedMember(m_originalURL);
497     info.addInstrumentedMember(m_encodingFromCharsetRule);
498     info.addVector(m_importRules);
499     info.addInstrumentedVector(m_childRules);
500     info.addHashMap(m_namespaces);
501     info.addVector(m_clients);
502 }
503
504 }