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