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