Refactor CachedResourceLoader: add CachedResourceRequest
[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 "EventSender.h"
36 #include "Frame.h"
37 #include "FrameLoader.h"
38 #include "FrameLoaderClient.h"
39 #include "FrameTree.h"
40 #include "FrameView.h"
41 #include "HTMLNames.h"
42 #include "HTMLParserIdioms.h"
43 #include "MediaList.h"
44 #include "MediaQueryEvaluator.h"
45 #include "Page.h"
46 #include "ScriptEventListener.h"
47 #include "SecurityOrigin.h"
48 #include "Settings.h"
49 #include "StyleResolver.h"
50 #include "StyleSheetContents.h"
51 #include <wtf/StdLibExtras.h>
52
53 namespace WebCore {
54
55 using namespace HTMLNames;
56
57 static LinkEventSender& linkLoadEventSender()
58 {
59     DEFINE_STATIC_LOCAL(LinkEventSender, sharedLoadEventSender, (eventNames().loadEvent));
60     return sharedLoadEventSender;
61 }
62
63 inline HTMLLinkElement::HTMLLinkElement(const QualifiedName& tagName, Document* document, bool createdByParser)
64     : HTMLElement(tagName, document)
65     , m_linkLoader(this)
66     , m_sizes(DOMSettableTokenList::create())
67     , m_disabledState(Unset)
68     , m_loading(false)
69     , m_createdByParser(createdByParser)
70     , m_isInShadowTree(false)
71     , m_firedLoad(false)
72     , m_loadedSheet(false)
73     , m_pendingSheetType(None)
74 {
75     ASSERT(hasTagName(linkTag));
76 }
77
78 PassRefPtr<HTMLLinkElement> HTMLLinkElement::create(const QualifiedName& tagName, Document* document, bool createdByParser)
79 {
80     return adoptRef(new HTMLLinkElement(tagName, document, createdByParser));
81 }
82
83 HTMLLinkElement::~HTMLLinkElement()
84 {
85     if (m_sheet)
86         m_sheet->clearOwnerNode();
87
88     if (m_cachedSheet)
89         m_cachedSheet->removeClient(this);
90
91     if (inDocument())
92         document()->styleSheetCollection()->removeStyleSheetCandidateNode(this);
93
94     linkLoadEventSender().cancelEvent(this);
95 }
96
97 void HTMLLinkElement::setDisabledState(bool disabled)
98 {
99     DisabledState oldDisabledState = m_disabledState;
100     m_disabledState = disabled ? Disabled : EnabledViaScript;
101     if (oldDisabledState != m_disabledState) {
102         // If we change the disabled state while the sheet is still loading, then we have to
103         // perform three checks:
104         if (styleSheetIsLoading()) {
105             // Check #1: The sheet becomes disabled while loading.
106             if (m_disabledState == Disabled)
107                 removePendingSheet();
108
109             // Check #2: An alternate sheet becomes enabled while it is still loading.
110             if (m_relAttribute.m_isAlternate && m_disabledState == EnabledViaScript)
111                 addPendingSheet(Blocking);
112
113             // Check #3: A main sheet becomes enabled while it was still loading and
114             // after it was disabled via script. It takes really terrible code to make this
115             // happen (a double toggle for no reason essentially). This happens on
116             // virtualplastic.net, which manages to do about 12 enable/disables on only 3
117             // sheets. :)
118             if (!m_relAttribute.m_isAlternate && m_disabledState == EnabledViaScript && oldDisabledState == Disabled)
119                 addPendingSheet(Blocking);
120
121             // If the sheet is already loading just bail.
122             return;
123         }
124
125         // Load the sheet, since it's never been loaded before.
126         if (!m_sheet && m_disabledState == EnabledViaScript)
127             process();
128         else
129             document()->styleResolverChanged(DeferRecalcStyle); // Update the style selector.
130     }
131 }
132
133 void HTMLLinkElement::parseAttribute(const Attribute& attribute)
134 {
135     if (attribute.name() == relAttr) {
136         m_relAttribute = LinkRelAttribute(attribute.value());
137         process();
138     } else if (attribute.name() == hrefAttr) {
139         String url = stripLeadingAndTrailingHTMLSpaces(attribute.value());
140         m_url = url.isEmpty() ? KURL() : document()->completeURL(url);
141         process();
142     } else if (attribute.name() == typeAttr) {
143         m_type = attribute.value();
144         process();
145     } else if (attribute.name() == sizesAttr) {
146         setSizes(attribute.value());
147         process();
148     } else if (attribute.name() == mediaAttr) {
149         m_media = attribute.value().string().lower();
150         process();
151     } else if (attribute.name() == disabledAttr)
152         setDisabledState(!attribute.isNull());
153     else if (attribute.name() == onbeforeloadAttr)
154         setAttributeEventListener(eventNames().beforeloadEvent, createAttributeEventListener(this, attribute));
155     else if (attribute.name() == onloadAttr)
156         setAttributeEventListener(eventNames().loadEvent, createAttributeEventListener(this, attribute));
157     else if (attribute.name() == onerrorAttr)
158         setAttributeEventListener(eventNames().errorEvent, createAttributeEventListener(this, attribute));
159     else {
160         if (attribute.name() == titleAttr && m_sheet)
161             m_sheet->setTitle(attribute.value());
162         HTMLElement::parseAttribute(attribute);
163     }
164 }
165
166 bool HTMLLinkElement::shouldLoadLink()
167 {
168     RefPtr<Document> originalDocument = document();
169     if (!dispatchBeforeLoadEvent(m_url))
170         return false;
171     // A beforeload handler might have removed us from the document or changed the document.
172     if (!inDocument() || document() != originalDocument)
173         return false;
174     return true;
175 }
176
177 void HTMLLinkElement::process()
178 {
179     if (!inDocument() || m_isInShadowTree) {
180         ASSERT(!m_sheet);
181         return;
182     }
183
184     String type = m_type.lower();
185
186     if (!m_linkLoader.loadLink(m_relAttribute, type, m_sizes->toString(), m_url, document()))
187         return;
188
189     bool acceptIfTypeContainsTextCSS = document()->page() && document()->page()->settings() && document()->page()->settings()->treatsAnyTextCSSLinkAsStylesheet();
190
191     if (m_disabledState != Disabled && (m_relAttribute.m_isStyleSheet || (acceptIfTypeContainsTextCSS && type.contains("text/css")))
192         && document()->frame() && m_url.isValid()) {
193         
194         String charset = getAttribute(charsetAttr);
195         if (charset.isEmpty() && document()->frame())
196             charset = document()->charset();
197         
198         if (m_cachedSheet) {
199             removePendingSheet();
200             m_cachedSheet->removeClient(this);
201             m_cachedSheet = 0;
202         }
203
204         if (!shouldLoadLink())
205             return;
206
207         m_loading = true;
208
209         bool mediaQueryMatches = true;
210         if (!m_media.isEmpty()) {
211             RefPtr<RenderStyle> documentStyle = StyleResolver::styleForDocument(document());
212             RefPtr<MediaQuerySet> media = MediaQuerySet::createAllowingDescriptionSyntax(m_media);
213             MediaQueryEvaluator evaluator(document()->frame()->view()->mediaType(), document()->frame(), documentStyle.get());
214             mediaQueryMatches = evaluator.eval(media.get());
215         }
216
217         // Don't hold up render tree construction and script execution on stylesheets
218         // that are not needed for the rendering at the moment.
219         bool blocking = mediaQueryMatches && !isAlternate();
220         addPendingSheet(blocking ? Blocking : NonBlocking);
221
222         // Load stylesheets that are not needed for the rendering immediately with low priority.
223         ResourceLoadPriority priority = blocking ? ResourceLoadPriorityUnresolved : ResourceLoadPriorityVeryLow;
224         CachedResourceRequest request(ResourceRequest(document()->completeURL(m_url)), charset, priority);
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(DeferRecalcStyle);
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     RefPtr<Node> protector(this);
303
304     CSSParserContext parserContext(document(), baseURL, charset);
305
306 #if ENABLE(PARSED_STYLE_SHEET_CACHING)
307     if (RefPtr<StyleSheetContents> restoredSheet = const_cast<CachedCSSStyleSheet*>(cachedStyleSheet)->restoreParsedStyleSheet(parserContext)) {
308         ASSERT(restoredSheet->isCacheable());
309         ASSERT(!restoredSheet->isLoading());
310
311         m_sheet = CSSStyleSheet::create(restoredSheet, this);
312         m_sheet->setMediaQueries(MediaQuerySet::createAllowingDescriptionSyntax(m_media));
313         m_sheet->setTitle(title());
314
315         m_loading = false;
316         sheetLoaded();
317         notifyLoadedSheetAndAllCriticalSubresources(false);
318         return;
319     }
320 #endif
321
322     RefPtr<StyleSheetContents> styleSheet = StyleSheetContents::create(href, parserContext);
323
324     m_sheet = CSSStyleSheet::create(styleSheet, this);
325     m_sheet->setMediaQueries(MediaQuerySet::createAllowingDescriptionSyntax(m_media));
326     m_sheet->setTitle(title());
327
328     styleSheet->parseAuthorStyleSheet(cachedStyleSheet, document()->securityOrigin());
329
330     m_loading = false;
331     styleSheet->notifyLoadedSheet(cachedStyleSheet);
332     styleSheet->checkLoaded();
333
334 #if ENABLE(PARSED_STYLE_SHEET_CACHING)
335     if (styleSheet->isCacheable())
336         const_cast<CachedCSSStyleSheet*>(cachedStyleSheet)->saveParsedStyleSheet(styleSheet);
337 #endif
338 }
339
340 bool HTMLLinkElement::styleSheetIsLoading() const
341 {
342     if (m_loading)
343         return true;
344     if (!m_sheet)
345         return false;
346     return m_sheet->contents()->isLoading();
347 }
348
349 void HTMLLinkElement::linkLoaded()
350 {
351     dispatchEvent(Event::create(eventNames().loadEvent, false, false));
352 }
353
354 void HTMLLinkElement::linkLoadingErrored()
355 {
356     dispatchEvent(Event::create(eventNames().errorEvent, false, false));
357 }
358
359 bool HTMLLinkElement::sheetLoaded()
360 {
361     if (!styleSheetIsLoading()) {
362         removePendingSheet();
363         return true;
364     }
365     return false;
366 }
367
368 void HTMLLinkElement::dispatchPendingLoadEvents()
369 {
370     linkLoadEventSender().dispatchPendingEvents();
371 }
372
373 void HTMLLinkElement::dispatchPendingEvent(LinkEventSender* eventSender)
374 {
375     ASSERT_UNUSED(eventSender, eventSender == &linkLoadEventSender());
376     if (m_loadedSheet)
377         linkLoaded();
378     else
379         linkLoadingErrored();
380 }
381
382 void HTMLLinkElement::notifyLoadedSheetAndAllCriticalSubresources(bool errorOccurred)
383 {
384     if (m_firedLoad)
385         return;
386     m_loadedSheet = !errorOccurred;
387     linkLoadEventSender().dispatchEventSoon(this);
388     m_firedLoad = true;
389 }
390
391 void HTMLLinkElement::startLoadingDynamicSheet()
392 {
393     // We don't support multiple blocking sheets.
394     ASSERT(m_pendingSheetType < Blocking);
395     addPendingSheet(Blocking);
396 }
397
398 bool HTMLLinkElement::isURLAttribute(const Attribute& attribute) const
399 {
400     return attribute.name() == hrefAttr || HTMLElement::isURLAttribute(attribute);
401 }
402
403 KURL HTMLLinkElement::href() const
404 {
405     return document()->completeURL(getAttribute(hrefAttr));
406 }
407
408 String HTMLLinkElement::rel() const
409 {
410     return getAttribute(relAttr);
411 }
412
413 String HTMLLinkElement::target() const
414 {
415     return getAttribute(targetAttr);
416 }
417
418 String HTMLLinkElement::type() const
419 {
420     return getAttribute(typeAttr);
421 }
422
423 IconType HTMLLinkElement::iconType() const
424 {
425     return m_relAttribute.m_iconType;
426 }
427
428 String HTMLLinkElement::iconSizes() const
429 {
430     return m_sizes->toString();
431 }
432
433 void HTMLLinkElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
434 {
435     HTMLElement::addSubresourceAttributeURLs(urls);
436
437     // Favicons are handled by a special case in LegacyWebArchive::create()
438     if (m_relAttribute.m_iconType != InvalidIcon)
439         return;
440
441     if (!m_relAttribute.m_isStyleSheet)
442         return;
443     
444     // Append the URL of this link element.
445     addSubresourceURL(urls, href());
446     
447     // Walk the URLs linked by the linked-to stylesheet.
448     if (CSSStyleSheet* styleSheet = const_cast<HTMLLinkElement*>(this)->sheet())
449         styleSheet->contents()->addSubresourceStyleURLs(urls);
450 }
451
452 void HTMLLinkElement::addPendingSheet(PendingSheetType type)
453 {
454     if (type <= m_pendingSheetType)
455         return;
456     m_pendingSheetType = type;
457
458     if (m_pendingSheetType == NonBlocking)
459         return;
460     document()->styleSheetCollection()->addPendingSheet();
461 }
462
463 void HTMLLinkElement::removePendingSheet(RemovePendingSheetNotificationType notification)
464 {
465     PendingSheetType type = m_pendingSheetType;
466     m_pendingSheetType = None;
467
468     if (type == None)
469         return;
470     if (type == NonBlocking) {
471         // Document::removePendingSheet() triggers the style selector recalc for blocking sheets.
472         document()->styleResolverChanged(RecalcStyleImmediately);
473         return;
474     }
475
476     document()->styleSheetCollection()->removePendingSheet(
477         notification == RemovePendingSheetNotifyImmediately
478         ? DocumentStyleSheetCollection::RemovePendingSheetNotifyImmediately
479         : DocumentStyleSheetCollection::RemovePendingSheetNotifyLater);
480 }
481
482 DOMSettableTokenList* HTMLLinkElement::sizes() const
483 {
484     return m_sizes.get();
485 }
486
487 void HTMLLinkElement::setSizes(const String& value)
488 {
489     m_sizes->setValue(value);
490 }
491
492 #if ENABLE(MICRODATA)
493 String HTMLLinkElement::itemValueText() const
494 {
495     return getURLAttribute(hrefAttr);
496 }
497
498 void HTMLLinkElement::setItemValueText(const String& value, ExceptionCode&)
499 {
500     setAttribute(hrefAttr, value);
501 }
502 #endif
503
504 } // namespace WebCore