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