<https://webkit.org/b/119983> Add two missing RefPtr::release() in HTMLLinkElement.
[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 "CachedResourceRequest.h"
33 #include "Document.h"
34 #include "DocumentStyleSheetCollection.h"
35 #include "Event.h"
36 #include "EventSender.h"
37 #include "Frame.h"
38 #include "FrameLoader.h"
39 #include "FrameLoaderClient.h"
40 #include "FrameTree.h"
41 #include "FrameView.h"
42 #include "HTMLNames.h"
43 #include "HTMLParserIdioms.h"
44 #include "MediaList.h"
45 #include "MediaQueryEvaluator.h"
46 #include "Page.h"
47 #include "RenderStyle.h"
48 #include "ScriptEventListener.h"
49 #include "SecurityOrigin.h"
50 #include "Settings.h"
51 #include "StyleInheritedData.h"
52 #include "StyleResolveForDocument.h"
53 #include "StyleSheetContents.h"
54 #include <wtf/StdLibExtras.h>
55
56 namespace WebCore {
57
58 using namespace HTMLNames;
59
60 static LinkEventSender& linkLoadEventSender()
61 {
62     DEFINE_STATIC_LOCAL(LinkEventSender, sharedLoadEventSender, (eventNames().loadEvent));
63     return sharedLoadEventSender;
64 }
65
66 inline HTMLLinkElement::HTMLLinkElement(const QualifiedName& tagName, Document* document, bool createdByParser)
67     : HTMLElement(tagName, document)
68     , m_linkLoader(this)
69     , m_sizes(DOMSettableTokenList::create())
70     , m_disabledState(Unset)
71     , m_loading(false)
72     , m_createdByParser(createdByParser)
73     , m_isInShadowTree(false)
74     , m_firedLoad(false)
75     , m_loadedSheet(false)
76     , m_pendingSheetType(Unknown)
77 {
78     ASSERT(hasTagName(linkTag));
79 }
80
81 PassRefPtr<HTMLLinkElement> HTMLLinkElement::create(const QualifiedName& tagName, Document* document, bool createdByParser)
82 {
83     return adoptRef(new HTMLLinkElement(tagName, document, createdByParser));
84 }
85
86 HTMLLinkElement::~HTMLLinkElement()
87 {
88     if (m_sheet)
89         m_sheet->clearOwnerNode();
90
91     if (m_cachedSheet)
92         m_cachedSheet->removeClient(this);
93
94     if (inDocument())
95         document()->styleSheetCollection()->removeStyleSheetCandidateNode(this);
96
97     linkLoadEventSender().cancelEvent(this);
98 }
99
100 void HTMLLinkElement::setDisabledState(bool disabled)
101 {
102     DisabledState oldDisabledState = m_disabledState;
103     m_disabledState = disabled ? Disabled : EnabledViaScript;
104     if (oldDisabledState != m_disabledState) {
105         // If we change the disabled state while the sheet is still loading, then we have to
106         // perform three checks:
107         if (styleSheetIsLoading()) {
108             // Check #1: The sheet becomes disabled while loading.
109             if (m_disabledState == Disabled)
110                 removePendingSheet();
111
112             // Check #2: An alternate sheet becomes enabled while it is still loading.
113             if (m_relAttribute.m_isAlternate && m_disabledState == EnabledViaScript)
114                 addPendingSheet(ActiveSheet);
115
116             // Check #3: A main sheet becomes enabled while it was still loading and
117             // after it was disabled via script. It takes really terrible code to make this
118             // happen (a double toggle for no reason essentially). This happens on
119             // virtualplastic.net, which manages to do about 12 enable/disables on only 3
120             // sheets. :)
121             if (!m_relAttribute.m_isAlternate && m_disabledState == EnabledViaScript && oldDisabledState == Disabled)
122                 addPendingSheet(ActiveSheet);
123
124             // If the sheet is already loading just bail.
125             return;
126         }
127
128         // Load the sheet, since it's never been loaded before.
129         if (!m_sheet && m_disabledState == EnabledViaScript)
130             process();
131         else
132             document()->styleResolverChanged(DeferRecalcStyle); // Update the style selector.
133     }
134 }
135
136 void HTMLLinkElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
137 {
138     if (name == relAttr) {
139         m_relAttribute = LinkRelAttribute(value);
140         process();
141     } else if (name == hrefAttr) {
142         process();
143     } else if (name == typeAttr) {
144         m_type = value;
145         process();
146     } else if (name == sizesAttr) {
147         setSizes(value);
148         process();
149     } else if (name == mediaAttr) {
150         m_media = value.string().lower();
151         process();
152     } else if (name == disabledAttr)
153         setDisabledState(!value.isNull());
154     else if (name == onbeforeloadAttr)
155         setAttributeEventListener(eventNames().beforeloadEvent, createAttributeEventListener(this, name, value));
156     else {
157         if (name == titleAttr && m_sheet)
158             m_sheet->setTitle(value);
159         HTMLElement::parseAttribute(name, value);
160     }
161 }
162
163 bool HTMLLinkElement::shouldLoadLink()
164 {
165     RefPtr<Document> originalDocument = document();
166     if (!dispatchBeforeLoadEvent(getNonEmptyURLAttribute(hrefAttr)))
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     KURL url = getNonEmptyURLAttribute(hrefAttr);
183
184     if (!m_linkLoader.loadLink(m_relAttribute, type, m_sizes->toString(), url, document()))
185         return;
186
187     bool acceptIfTypeContainsTextCSS = document()->page() && document()->page()->settings().treatsAnyTextCSSLinkAsStylesheet();
188
189     if (m_disabledState != Disabled && (m_relAttribute.m_isStyleSheet || (acceptIfTypeContainsTextCSS && type.contains("text/css")))
190         && document()->frame() && url.isValid()) {
191         
192         String charset = getAttribute(charsetAttr);
193         if (charset.isEmpty() && document()->frame())
194             charset = document()->charset();
195         
196         if (m_cachedSheet) {
197             removePendingSheet();
198             m_cachedSheet->removeClient(this);
199             m_cachedSheet = 0;
200         }
201
202         if (!shouldLoadLink())
203             return;
204
205         m_loading = true;
206
207         bool mediaQueryMatches = true;
208         if (!m_media.isEmpty()) {
209             RefPtr<RenderStyle> documentStyle = Style::resolveForDocument(document());
210             RefPtr<MediaQuerySet> media = MediaQuerySet::createAllowingDescriptionSyntax(m_media);
211             MediaQueryEvaluator evaluator(document()->frame()->view()->mediaType(), document()->frame(), documentStyle.get());
212             mediaQueryMatches = evaluator.eval(media.get());
213         }
214
215         // Don't hold up render tree construction and script execution on stylesheets
216         // that are not needed for the rendering at the moment.
217         bool isActive = mediaQueryMatches && !isAlternate();
218         addPendingSheet(isActive ? ActiveSheet : InactiveSheet);
219
220         // Load stylesheets that are not needed for the rendering immediately with low priority.
221         ResourceLoadPriority priority = isActive ? ResourceLoadPriorityUnresolved : ResourceLoadPriorityVeryLow;
222         CachedResourceRequest request(ResourceRequest(document()->completeURL(url)), charset, priority);
223         request.setInitiator(this);
224         m_cachedSheet = document()->cachedResourceLoader()->requestCSSStyleSheet(request);
225         
226         if (m_cachedSheet)
227             m_cachedSheet->addClient(this);
228         else {
229             // The request may have been denied if (for example) the stylesheet is local and the document is remote.
230             m_loading = false;
231             removePendingSheet();
232         }
233     } else if (m_sheet) {
234         // we no longer contain a stylesheet, e.g. perhaps rel or type was changed
235         clearSheet();
236         document()->styleResolverChanged(DeferRecalcStyle);
237     }
238 }
239
240 void HTMLLinkElement::clearSheet()
241 {
242     ASSERT(m_sheet);
243     ASSERT(m_sheet->ownerNode() == this);
244     m_sheet->clearOwnerNode();
245     m_sheet = 0;
246 }
247
248 Node::InsertionNotificationRequest HTMLLinkElement::insertedInto(ContainerNode* insertionPoint)
249 {
250     HTMLElement::insertedInto(insertionPoint);
251     if (!insertionPoint->inDocument())
252         return InsertionDone;
253
254     m_isInShadowTree = isInShadowTree();
255     if (m_isInShadowTree)
256         return InsertionDone;
257
258     document()->styleSheetCollection()->addStyleSheetCandidateNode(this, m_createdByParser);
259
260     process();
261     return InsertionDone;
262 }
263
264 void HTMLLinkElement::removedFrom(ContainerNode* insertionPoint)
265 {
266     HTMLElement::removedFrom(insertionPoint);
267     if (!insertionPoint->inDocument())
268         return;
269
270     m_linkLoader.released();
271
272     if (m_isInShadowTree) {
273         ASSERT(!m_sheet);
274         return;
275     }
276     document()->styleSheetCollection()->removeStyleSheetCandidateNode(this);
277
278     if (m_sheet)
279         clearSheet();
280
281     if (styleSheetIsLoading())
282         removePendingSheet(RemovePendingSheetNotifyLater);
283
284     if (document()->renderer())
285         document()->styleResolverChanged(DeferRecalcStyleIfNeeded);
286 }
287
288 void HTMLLinkElement::finishParsingChildren()
289 {
290     m_createdByParser = false;
291     HTMLElement::finishParsingChildren();
292 }
293
294 void HTMLLinkElement::setCSSStyleSheet(const String& href, const KURL& baseURL, const String& charset, const CachedCSSStyleSheet* cachedStyleSheet)
295 {
296     if (!inDocument()) {
297         ASSERT(!m_sheet);
298         return;
299     }
300     // Completing the sheet load may cause scripts to execute.
301     RefPtr<Node> protector(this);
302
303     CSSParserContext parserContext(document(), baseURL, charset);
304
305     if (RefPtr<StyleSheetContents> restoredSheet = const_cast<CachedCSSStyleSheet*>(cachedStyleSheet)->restoreParsedStyleSheet(parserContext)) {
306         ASSERT(restoredSheet->isCacheable());
307         ASSERT(!restoredSheet->isLoading());
308
309         m_sheet = CSSStyleSheet::create(restoredSheet.release(), this);
310         m_sheet->setMediaQueries(MediaQuerySet::createAllowingDescriptionSyntax(m_media));
311         m_sheet->setTitle(title());
312
313         m_loading = false;
314         sheetLoaded();
315         notifyLoadedSheetAndAllCriticalSubresources(false);
316         return;
317     }
318
319     RefPtr<StyleSheetContents> styleSheet = StyleSheetContents::create(href, parserContext);
320
321     m_sheet = CSSStyleSheet::create(styleSheet, this);
322     m_sheet->setMediaQueries(MediaQuerySet::createAllowingDescriptionSyntax(m_media));
323     m_sheet->setTitle(title());
324
325     styleSheet->parseAuthorStyleSheet(cachedStyleSheet, document()->securityOrigin());
326
327     m_loading = false;
328     styleSheet->notifyLoadedSheet(cachedStyleSheet);
329     styleSheet->checkLoaded();
330
331     if (styleSheet->isCacheable())
332         const_cast<CachedCSSStyleSheet*>(cachedStyleSheet)->saveParsedStyleSheet(styleSheet.release());
333 }
334
335 bool HTMLLinkElement::styleSheetIsLoading() const
336 {
337     if (m_loading)
338         return true;
339     if (!m_sheet)
340         return false;
341     return m_sheet->contents()->isLoading();
342 }
343
344 void HTMLLinkElement::linkLoaded()
345 {
346     dispatchEvent(Event::create(eventNames().loadEvent, false, false));
347 }
348
349 void HTMLLinkElement::linkLoadingErrored()
350 {
351     dispatchEvent(Event::create(eventNames().errorEvent, false, false));
352 }
353
354 bool HTMLLinkElement::sheetLoaded()
355 {
356     if (!styleSheetIsLoading()) {
357         removePendingSheet();
358         return true;
359     }
360     return false;
361 }
362
363 void HTMLLinkElement::dispatchPendingLoadEvents()
364 {
365     linkLoadEventSender().dispatchPendingEvents();
366 }
367
368 void HTMLLinkElement::dispatchPendingEvent(LinkEventSender* eventSender)
369 {
370     ASSERT_UNUSED(eventSender, eventSender == &linkLoadEventSender());
371     if (m_loadedSheet)
372         linkLoaded();
373     else
374         linkLoadingErrored();
375 }
376
377 void HTMLLinkElement::notifyLoadedSheetAndAllCriticalSubresources(bool errorOccurred)
378 {
379     if (m_firedLoad)
380         return;
381     m_loadedSheet = !errorOccurred;
382     linkLoadEventSender().dispatchEventSoon(this);
383     m_firedLoad = true;
384 }
385
386 void HTMLLinkElement::startLoadingDynamicSheet()
387 {
388     // We don't support multiple active sheets.
389     ASSERT(m_pendingSheetType < ActiveSheet);
390     addPendingSheet(ActiveSheet);
391 }
392
393 bool HTMLLinkElement::isURLAttribute(const Attribute& attribute) const
394 {
395     return attribute.name().localName() == hrefAttr || HTMLElement::isURLAttribute(attribute);
396 }
397
398 KURL HTMLLinkElement::href() const
399 {
400     return document()->completeURL(getAttribute(hrefAttr));
401 }
402
403 String HTMLLinkElement::rel() const
404 {
405     return getAttribute(relAttr);
406 }
407
408 String HTMLLinkElement::target() const
409 {
410     return getAttribute(targetAttr);
411 }
412
413 String HTMLLinkElement::type() const
414 {
415     return getAttribute(typeAttr);
416 }
417
418 IconType HTMLLinkElement::iconType() const
419 {
420     return m_relAttribute.m_iconType;
421 }
422
423 String HTMLLinkElement::iconSizes() const
424 {
425     return m_sizes->toString();
426 }
427
428 void HTMLLinkElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
429 {
430     HTMLElement::addSubresourceAttributeURLs(urls);
431
432     // Favicons are handled by a special case in LegacyWebArchive::create()
433     if (m_relAttribute.m_iconType != InvalidIcon)
434         return;
435
436     if (!m_relAttribute.m_isStyleSheet)
437         return;
438     
439     // Append the URL of this link element.
440     addSubresourceURL(urls, href());
441     
442     // Walk the URLs linked by the linked-to stylesheet.
443     if (CSSStyleSheet* styleSheet = const_cast<HTMLLinkElement*>(this)->sheet())
444         styleSheet->contents()->addSubresourceStyleURLs(urls);
445 }
446
447 void HTMLLinkElement::addPendingSheet(PendingSheetType type)
448 {
449     if (type <= m_pendingSheetType)
450         return;
451     m_pendingSheetType = type;
452
453     if (m_pendingSheetType == InactiveSheet)
454         return;
455     document()->styleSheetCollection()->addPendingSheet();
456 }
457
458 void HTMLLinkElement::removePendingSheet(RemovePendingSheetNotificationType notification)
459 {
460     PendingSheetType type = m_pendingSheetType;
461     m_pendingSheetType = Unknown;
462
463     if (type == Unknown)
464         return;
465
466     if (type == InactiveSheet) {
467         // Document just needs to know about the sheet for exposure through document.styleSheets
468         document()->styleSheetCollection()->updateActiveStyleSheets(DocumentStyleSheetCollection::OptimizedUpdate);
469         return;
470     }
471
472     document()->styleSheetCollection()->removePendingSheet(
473         notification == RemovePendingSheetNotifyImmediately
474         ? DocumentStyleSheetCollection::RemovePendingSheetNotifyImmediately
475         : DocumentStyleSheetCollection::RemovePendingSheetNotifyLater);
476 }
477
478 DOMSettableTokenList* HTMLLinkElement::sizes() const
479 {
480     return m_sizes.get();
481 }
482
483 void HTMLLinkElement::setSizes(const String& value)
484 {
485     m_sizes->setValue(value);
486 }
487
488 } // namespace WebCore