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