Protect current element in HTMLLinkElement::setCSSStyleSheet
[WebKit-https.git] / Source / WebCore / html / HTMLLinkElement.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
6  * Copyright (C) 2009 Rob Buis (rwlbuis@gmail.com)
7  * Copyright (C) 2011 Google Inc. All rights reserved.
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Library General Public
11  * License as published by the Free Software Foundation; either
12  * version 2 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Library General Public License for more details.
18  *
19  * You should have received a copy of the GNU Library General Public License
20  * along with this library; see the file COPYING.LIB.  If not, write to
21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22  * Boston, MA 02110-1301, USA.
23  */
24
25 #include "config.h"
26 #include "HTMLLinkElement.h"
27
28 #include "Attribute.h"
29 #include "CachedCSSStyleSheet.h"
30 #include "CachedResource.h"
31 #include "CachedResourceLoader.h"
32 #include "Document.h"
33 #include "EventSender.h"
34 #include "Frame.h"
35 #include "FrameLoader.h"
36 #include "FrameLoaderClient.h"
37 #include "FrameTree.h"
38 #include "FrameView.h"
39 #include "HTMLNames.h"
40 #include "HTMLParserIdioms.h"
41 #include "MediaList.h"
42 #include "MediaQueryEvaluator.h"
43 #include "Page.h"
44 #include "ScriptEventListener.h"
45 #include "SecurityOrigin.h"
46 #include "Settings.h"
47 #include "StyleResolver.h"
48 #include <wtf/StdLibExtras.h>
49
50 namespace WebCore {
51
52 using namespace HTMLNames;
53
54 static LinkEventSender& linkLoadEventSender()
55 {
56     DEFINE_STATIC_LOCAL(LinkEventSender, sharedLoadEventSender, (eventNames().loadEvent));
57     return sharedLoadEventSender;
58 }
59
60 inline HTMLLinkElement::HTMLLinkElement(const QualifiedName& tagName, Document* document, bool createdByParser)
61     : HTMLElement(tagName, document)
62     , m_linkLoader(this)
63     , m_sizes(DOMSettableTokenList::create())
64     , m_disabledState(Unset)
65     , m_loading(false)
66     , m_createdByParser(createdByParser)
67     , m_isInShadowTree(false)
68     , m_firedLoad(false)
69     , m_loadedSheet(false)
70     , m_pendingSheetType(None)
71 {
72     ASSERT(hasTagName(linkTag));
73 }
74
75 PassRefPtr<HTMLLinkElement> HTMLLinkElement::create(const QualifiedName& tagName, Document* document, bool createdByParser)
76 {
77     return adoptRef(new HTMLLinkElement(tagName, document, createdByParser));
78 }
79
80 HTMLLinkElement::~HTMLLinkElement()
81 {
82     if (m_sheet)
83         m_sheet->clearOwnerNode();
84
85     if (m_cachedSheet)
86         m_cachedSheet->removeClient(this);
87
88     if (inDocument())
89         document()->removeStyleSheetCandidateNode(this);
90
91     linkLoadEventSender().cancelEvent(this);
92 }
93
94 void HTMLLinkElement::setDisabledState(bool disabled)
95 {
96     DisabledState oldDisabledState = m_disabledState;
97     m_disabledState = disabled ? Disabled : EnabledViaScript;
98     if (oldDisabledState != m_disabledState) {
99         // If we change the disabled state while the sheet is still loading, then we have to
100         // perform three checks:
101         if (styleSheetIsLoading()) {
102             // Check #1: The sheet becomes disabled while loading.
103             if (m_disabledState == Disabled)
104                 removePendingSheet();
105
106             // Check #2: An alternate sheet becomes enabled while it is still loading.
107             if (m_relAttribute.m_isAlternate && m_disabledState == EnabledViaScript)
108                 addPendingSheet(Blocking);
109
110             // Check #3: A main sheet becomes enabled while it was still loading and
111             // after it was disabled via script. It takes really terrible code to make this
112             // happen (a double toggle for no reason essentially). This happens on
113             // virtualplastic.net, which manages to do about 12 enable/disables on only 3
114             // sheets. :)
115             if (!m_relAttribute.m_isAlternate && m_disabledState == EnabledViaScript && oldDisabledState == Disabled)
116                 addPendingSheet(Blocking);
117
118             // If the sheet is already loading just bail.
119             return;
120         }
121
122         // Load the sheet, since it's never been loaded before.
123         if (!m_sheet && m_disabledState == EnabledViaScript)
124             process();
125         else
126             document()->styleResolverChanged(DeferRecalcStyle); // Update the style selector.
127     }
128 }
129
130 void HTMLLinkElement::parseAttribute(Attribute* attr)
131 {
132     if (attr->name() == relAttr) {
133         m_relAttribute = LinkRelAttribute(attr->value());
134         process();
135     } else if (attr->name() == hrefAttr) {
136         String url = stripLeadingAndTrailingHTMLSpaces(attr->value());
137         m_url = url.isEmpty() ? KURL() : document()->completeURL(url);
138         process();
139     } else if (attr->name() == typeAttr) {
140         m_type = attr->value();
141         process();
142     } else if (attr->name() == sizesAttr) {
143         setSizes(attr->value());
144         process();
145     } else if (attr->name() == mediaAttr) {
146         m_media = attr->value().string().lower();
147         process();
148     } else if (attr->name() == disabledAttr)
149         setDisabledState(!attr->isNull());
150     else if (attr->name() == onbeforeloadAttr)
151         setAttributeEventListener(eventNames().beforeloadEvent, createAttributeEventListener(this, attr));
152     else if (attr->name() == onloadAttr)
153         setAttributeEventListener(eventNames().loadEvent, createAttributeEventListener(this, attr));
154     else if (attr->name() == onerrorAttr)
155         setAttributeEventListener(eventNames().errorEvent, createAttributeEventListener(this, attr));
156     else {
157         if (attr->name() == titleAttr && m_sheet)
158             m_sheet->internal()->setTitle(attr->value());
159         HTMLElement::parseAttribute(attr);
160     }
161 }
162
163 bool HTMLLinkElement::shouldLoadLink()
164 {
165     RefPtr<Document> originalDocument = document();
166     if (!dispatchBeforeLoadEvent(m_url))
167         return false;
168     // A beforeload handler might have removed us from the document or changed the document.
169     if (!inDocument() || document() != originalDocument)
170         return false;
171     return true;
172 }
173
174 void HTMLLinkElement::process()
175 {
176     if (!inDocument() || m_isInShadowTree) {
177         ASSERT(!m_sheet);
178         return;
179     }
180
181     String type = m_type.lower();
182
183     if (!m_linkLoader.loadLink(m_relAttribute, type, m_sizes->toString(), m_url, document()))
184         return;
185
186     bool acceptIfTypeContainsTextCSS = document()->page() && document()->page()->settings() && document()->page()->settings()->treatsAnyTextCSSLinkAsStylesheet();
187
188     if (m_disabledState != Disabled && (m_relAttribute.m_isStyleSheet || (acceptIfTypeContainsTextCSS && type.contains("text/css")))
189         && document()->frame() && m_url.isValid()) {
190         
191         String charset = getAttribute(charsetAttr);
192         if (charset.isEmpty() && document()->frame())
193             charset = document()->charset();
194         
195         if (m_cachedSheet) {
196             removePendingSheet();
197             m_cachedSheet->removeClient(this);
198             m_cachedSheet = 0;
199         }
200
201         if (!shouldLoadLink())
202             return;
203
204         m_loading = true;
205
206         bool mediaQueryMatches = true;
207         if (!m_media.isEmpty()) {
208             RefPtr<RenderStyle> documentStyle = StyleResolver::styleForDocument(document());
209             RefPtr<MediaQuerySet> media = MediaQuerySet::createAllowingDescriptionSyntax(m_media);
210             MediaQueryEvaluator evaluator(document()->frame()->view()->mediaType(), document()->frame(), documentStyle.get());
211             mediaQueryMatches = evaluator.eval(media.get());
212         }
213
214         // Don't hold up render tree construction and script execution on stylesheets
215         // that are not needed for the rendering at the moment.
216         bool blocking = mediaQueryMatches && !isAlternate();
217         addPendingSheet(blocking ? Blocking : NonBlocking);
218
219         // Load stylesheets that are not needed for the rendering immediately with low priority.
220         ResourceLoadPriority priority = blocking ? ResourceLoadPriorityUnresolved : ResourceLoadPriorityVeryLow;
221         ResourceRequest request(document()->completeURL(m_url));
222         m_cachedSheet = document()->cachedResourceLoader()->requestCSSStyleSheet(request, charset, priority);
223         
224         if (m_cachedSheet)
225             m_cachedSheet->addClient(this);
226         else {
227             // The request may have been denied if (for example) the stylesheet is local and the document is remote.
228             m_loading = false;
229             removePendingSheet();
230         }
231     } else if (m_sheet) {
232         // we no longer contain a stylesheet, e.g. perhaps rel or type was changed
233         clearSheet();
234         document()->styleResolverChanged(DeferRecalcStyle);
235     }
236 }
237
238 void HTMLLinkElement::clearSheet()
239 {
240     ASSERT(m_sheet);
241     ASSERT(m_sheet->ownerNode() == this);
242     m_sheet->clearOwnerNode();
243     m_sheet = 0;
244 }
245
246 Node::InsertionNotificationRequest HTMLLinkElement::insertedInto(Node* insertionPoint)
247 {
248     HTMLElement::insertedInto(insertionPoint);
249     if (!insertionPoint->inDocument())
250         return InsertionDone;
251
252     m_isInShadowTree = isInShadowTree();
253     if (m_isInShadowTree)
254         return InsertionDone;
255
256     document()->addStyleSheetCandidateNode(this, m_createdByParser);
257
258     process();
259     return InsertionDone;
260 }
261
262 void HTMLLinkElement::removedFrom(Node* insertionPoint)
263 {
264     HTMLElement::removedFrom(insertionPoint);
265     if (!insertionPoint->inDocument())
266         return;
267
268     if (m_isInShadowTree) {
269         ASSERT(!m_sheet);
270         return;
271     }
272     document()->removeStyleSheetCandidateNode(this);
273
274     if (m_sheet)
275         clearSheet();
276
277     if (styleSheetIsLoading())
278         removePendingSheet();
279
280     if (document()->renderer())
281         document()->styleResolverChanged(DeferRecalcStyle);
282 }
283
284 void HTMLLinkElement::finishParsingChildren()
285 {
286     m_createdByParser = false;
287     HTMLElement::finishParsingChildren();
288 }
289
290 void HTMLLinkElement::setCSSStyleSheet(const String& href, const KURL& baseURL, const String& charset, const CachedCSSStyleSheet* cachedStyleSheet)
291 {
292     if (!inDocument()) {
293         ASSERT(!m_sheet);
294         return;
295     }
296     // Completing the sheet load may cause scripts to execute.
297     RefPtr<Node> protector(this);
298
299     CSSParserContext parserContext(document(), baseURL, charset);
300
301     if (RefPtr<StyleSheetInternal> restoredSheet = const_cast<CachedCSSStyleSheet*>(cachedStyleSheet)->restoreParsedStyleSheet(parserContext)) {
302         ASSERT(restoredSheet->isCacheable());
303         ASSERT(!restoredSheet->isLoading());
304
305         // restoreParsedStyleSheet() currently returns a copy so it is ok to mutate the queries and the title like this.
306         RefPtr<MediaQuerySet> media = MediaQuerySet::createAllowingDescriptionSyntax(m_media);
307         restoredSheet->setMediaQueries(media.release());
308         restoredSheet->setTitle(title());
309
310         m_sheet = CSSStyleSheet::create(restoredSheet, this);
311         m_loading = false;
312         sheetLoaded();
313         notifyLoadedSheetAndAllCriticalSubresources(false);
314         return;
315     }
316
317     RefPtr<StyleSheetInternal> styleSheet = StyleSheetInternal::create(href, baseURL, parserContext);
318     m_sheet = CSSStyleSheet::create(styleSheet, this);
319
320     styleSheet->parseUserStyleSheet(cachedStyleSheet, document()->securityOrigin());
321
322     RefPtr<MediaQuerySet> media = MediaQuerySet::createAllowingDescriptionSyntax(m_media);
323     styleSheet->setMediaQueries(media.release());
324     styleSheet->setTitle(title());
325
326     m_loading = false;
327     styleSheet->notifyLoadedSheet(cachedStyleSheet);
328     styleSheet->checkLoaded();
329
330     if (styleSheet->isCacheable())
331         const_cast<CachedCSSStyleSheet*>(cachedStyleSheet)->saveParsedStyleSheet(styleSheet);
332 }
333
334 bool HTMLLinkElement::styleSheetIsLoading() const
335 {
336     if (m_loading)
337         return true;
338     if (!m_sheet)
339         return false;
340     return m_sheet->internal()->isLoading();
341 }
342
343 void HTMLLinkElement::linkLoaded()
344 {
345     dispatchEvent(Event::create(eventNames().loadEvent, false, false));
346 }
347
348 void HTMLLinkElement::linkLoadingErrored()
349 {
350     dispatchEvent(Event::create(eventNames().errorEvent, false, false));
351 }
352
353 bool HTMLLinkElement::sheetLoaded()
354 {
355     if (!styleSheetIsLoading()) {
356         removePendingSheet();
357         return true;
358     }
359     return false;
360 }
361
362 void HTMLLinkElement::dispatchPendingLoadEvents()
363 {
364     linkLoadEventSender().dispatchPendingEvents();
365 }
366
367 void HTMLLinkElement::dispatchPendingEvent(LinkEventSender* eventSender)
368 {
369     ASSERT_UNUSED(eventSender, eventSender == &linkLoadEventSender());
370     if (m_loadedSheet)
371         linkLoaded();
372     else
373         linkLoadingErrored();
374 }
375
376 void HTMLLinkElement::notifyLoadedSheetAndAllCriticalSubresources(bool errorOccurred)
377 {
378     if (m_firedLoad)
379         return;
380     m_loadedSheet = !errorOccurred;
381     linkLoadEventSender().dispatchEventSoon(this);
382     m_firedLoad = true;
383 }
384
385 void HTMLLinkElement::startLoadingDynamicSheet()
386 {
387     // We don't support multiple blocking sheets.
388     ASSERT(m_pendingSheetType < Blocking);
389     addPendingSheet(Blocking);
390 }
391
392 bool HTMLLinkElement::isURLAttribute(Attribute *attr) const
393 {
394     return attr->name() == hrefAttr || HTMLElement::isURLAttribute(attr);
395 }
396
397 KURL HTMLLinkElement::href() const
398 {
399     return document()->completeURL(getAttribute(hrefAttr));
400 }
401
402 String HTMLLinkElement::rel() const
403 {
404     return getAttribute(relAttr);
405 }
406
407 String HTMLLinkElement::target() const
408 {
409     return getAttribute(targetAttr);
410 }
411
412 String HTMLLinkElement::type() const
413 {
414     return getAttribute(typeAttr);
415 }
416
417 void HTMLLinkElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
418 {
419     HTMLElement::addSubresourceAttributeURLs(urls);
420
421     // Favicons are handled by a special case in LegacyWebArchive::create()
422     if (m_relAttribute.m_iconType != InvalidIcon)
423         return;
424
425     if (!m_relAttribute.m_isStyleSheet)
426         return;
427     
428     // Append the URL of this link element.
429     addSubresourceURL(urls, href());
430     
431     // Walk the URLs linked by the linked-to stylesheet.
432     if (CSSStyleSheet* styleSheet = const_cast<HTMLLinkElement*>(this)->sheet())
433         styleSheet->internal()->addSubresourceStyleURLs(urls);
434 }
435
436 void HTMLLinkElement::addPendingSheet(PendingSheetType type)
437 {
438     if (type <= m_pendingSheetType)
439         return;
440     m_pendingSheetType = type;
441
442     if (m_pendingSheetType == NonBlocking)
443         return;
444     document()->addPendingSheet();
445 }
446
447 void HTMLLinkElement::removePendingSheet()
448 {
449     PendingSheetType type = m_pendingSheetType;
450     m_pendingSheetType = None;
451
452     if (type == None)
453         return;
454     if (type == NonBlocking) {
455         // Document::removePendingSheet() triggers the style selector recalc for blocking sheets.
456         document()->styleResolverChanged(RecalcStyleImmediately);
457         return;
458     }
459     document()->removePendingSheet();
460 }
461
462 DOMSettableTokenList* HTMLLinkElement::sizes() const
463 {
464     return m_sizes.get();
465 }
466
467 void HTMLLinkElement::setSizes(const String& value)
468 {
469     m_sizes->setValue(value);
470 }
471
472 #if ENABLE(MICRODATA)
473 String HTMLLinkElement::itemValueText() const
474 {
475     return getURLAttribute(hrefAttr);
476 }
477
478 void HTMLLinkElement::setItemValueText(const String& value, ExceptionCode&)
479 {
480     setAttribute(hrefAttr, value);
481 }
482 #endif
483
484 } // namespace WebCore