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