fe0bcc1cb314d9b50c4ada6fa1af66f14cadbfcc
[WebKit-https.git] / Source / WebCore / dom / DOMImplementation.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) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
6  * Copyright (C) 2006 Samuel Weinig (sam@webkit.org)
7  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
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 "DOMImplementation.h"
27
28 #include "ContentType.h"
29 #include "CSSStyleSheet.h"
30 #include "DocumentType.h"
31 #include "Element.h"
32 #include "ExceptionCode.h"
33 #include "Frame.h"
34 #include "FrameLoader.h"
35 #include "FrameLoaderClient.h"
36 #include "FTPDirectoryDocument.h"
37 #include "HTMLDocument.h"
38 #include "Image.h"
39 #include "ImageDocument.h"
40 #include "MainFrame.h"
41 #include "MediaDocument.h"
42 #include "MediaList.h"
43 #include "MIMETypeRegistry.h"
44 #include "Page.h"
45 #include "PluginData.h"
46 #include "PluginDocument.h"
47 #include "SVGDocument.h"
48 #include "SVGNames.h"
49 #include "SecurityOrigin.h"
50 #include "SecurityOriginPolicy.h"
51 #include "Settings.h"
52 #include "StyleSheetContents.h"
53 #include "SubframeLoader.h"
54 #include "TextDocument.h"
55 #include "XMLNames.h"
56 #include <wtf/StdLibExtras.h>
57
58 namespace WebCore {
59
60 typedef HashSet<String, CaseFoldingHash> FeatureSet;
61
62 static void addString(FeatureSet& set, const char* string)
63 {
64     set.add(string);
65 }
66
67 #if ENABLE(VIDEO)
68 class DOMImplementationSupportsTypeClient : public MediaPlayerSupportsTypeClient {
69 public:
70     DOMImplementationSupportsTypeClient(bool needsHacks, const String& host)
71         : m_needsHacks(needsHacks)
72         , m_host(host)
73     {
74     }
75
76 private:
77     virtual bool mediaPlayerNeedsSiteSpecificHacks() const override { return m_needsHacks; }
78     virtual String mediaPlayerDocumentHost() const override { return m_host; }
79
80     bool m_needsHacks;
81     String m_host;
82 };
83 #endif
84
85 static bool isSupportedSVG10Feature(const String& feature, const String& version)
86 {
87     if (!version.isEmpty() && version != "1.0")
88         return false;
89
90     static bool initialized = false;
91     DEPRECATED_DEFINE_STATIC_LOCAL(FeatureSet, svgFeatures, ());
92     if (!initialized) {
93 #if ENABLE(SVG_FONTS)
94         addString(svgFeatures, "svg");
95         addString(svgFeatures, "svg.static");
96 #endif
97 //      addString(svgFeatures, "svg.animation");
98 //      addString(svgFeatures, "svg.dynamic");
99 //      addString(svgFeatures, "svg.dom.animation");
100 //      addString(svgFeatures, "svg.dom.dynamic");
101 #if ENABLE(SVG_FONTS)
102         addString(svgFeatures, "dom");
103         addString(svgFeatures, "dom.svg");
104         addString(svgFeatures, "dom.svg.static");
105 #endif
106 //      addString(svgFeatures, "svg.all");
107 //      addString(svgFeatures, "dom.svg.all");
108         initialized = true;
109     }
110     return feature.startsWith("org.w3c.", false)
111         && svgFeatures.contains(feature.right(feature.length() - 8));
112 }
113
114 static bool isSupportedSVG11Feature(const String& feature, const String& version)
115 {
116     if (!version.isEmpty() && version != "1.1")
117         return false;
118
119     static bool initialized = false;
120     DEPRECATED_DEFINE_STATIC_LOCAL(FeatureSet, svgFeatures, ());
121     if (!initialized) {
122         // Sadly, we cannot claim to implement any of the SVG 1.1 generic feature sets
123         // lack of Font and Filter support.
124         // http://bugs.webkit.org/show_bug.cgi?id=15480
125 #if ENABLE(SVG_FONTS)
126         addString(svgFeatures, "SVG");
127         addString(svgFeatures, "SVGDOM");
128         addString(svgFeatures, "SVG-static");
129         addString(svgFeatures, "SVGDOM-static");
130 #endif
131         addString(svgFeatures, "SVG-animation");
132         addString(svgFeatures, "SVGDOM-animation");
133 //      addString(svgFeatures, "SVG-dynamic);
134 //      addString(svgFeatures, "SVGDOM-dynamic);
135         addString(svgFeatures, "CoreAttribute");
136         addString(svgFeatures, "Structure");
137         addString(svgFeatures, "BasicStructure");
138         addString(svgFeatures, "ContainerAttribute");
139         addString(svgFeatures, "ConditionalProcessing");
140         addString(svgFeatures, "Image");
141         addString(svgFeatures, "Style");
142         addString(svgFeatures, "ViewportAttribute");
143         addString(svgFeatures, "Shape");
144         addString(svgFeatures, "Text");
145         addString(svgFeatures, "BasicText");
146         addString(svgFeatures, "PaintAttribute");
147         addString(svgFeatures, "BasicPaintAttribute");
148         addString(svgFeatures, "OpacityAttribute");
149         addString(svgFeatures, "GraphicsAttribute");
150         addString(svgFeatures, "BaseGraphicsAttribute");
151         addString(svgFeatures, "Marker");
152 //      addString(svgFeatures, "ColorProfile"); // requires color-profile, bug 6037
153         addString(svgFeatures, "Gradient");
154         addString(svgFeatures, "Pattern");
155         addString(svgFeatures, "Clip");
156         addString(svgFeatures, "BasicClip");
157         addString(svgFeatures, "Mask");
158         addString(svgFeatures, "Filter");
159         addString(svgFeatures, "BasicFilter");
160         addString(svgFeatures, "DocumentEventsAttribute");
161         addString(svgFeatures, "GraphicalEventsAttribute");
162 //      addString(svgFeatures, "AnimationEventsAttribute");
163         addString(svgFeatures, "Cursor");
164         addString(svgFeatures, "Hyperlinking");
165         addString(svgFeatures, "XlinkAttribute");
166         addString(svgFeatures, "ExternalResourcesRequired");
167         addString(svgFeatures, "View");
168         addString(svgFeatures, "Script");
169         addString(svgFeatures, "Animation"); 
170 #if ENABLE(SVG_FONTS)
171         addString(svgFeatures, "Font");
172         addString(svgFeatures, "BasicFont");
173 #endif
174         addString(svgFeatures, "Extensibility");
175         initialized = true;
176     }
177     return feature.startsWith("http://www.w3.org/tr/svg11/feature#", false)
178         && svgFeatures.contains(feature.right(feature.length() - 35));
179 }
180
181 DOMImplementation::DOMImplementation(Document& document)
182     : m_document(document)
183 {
184 }
185
186 bool DOMImplementation::hasFeature(const String& feature, const String& version)
187 {
188     if (feature.startsWith("http://www.w3.org/TR/SVG", false)
189         || feature.startsWith("org.w3c.dom.svg", false)
190         || feature.startsWith("org.w3c.svg", false)) {
191         // FIXME: SVG 2.0 support?
192         return isSupportedSVG10Feature(feature, version) || isSupportedSVG11Feature(feature, version);
193     }
194
195     // FIXME: SVG specifications <http://www.w3.org/TR/SVG/script.html#InterfaceSVGZoomEvent>
196     // and <http://www.w3.org/TR/SVG2/interact.html#InterfaceSVGZoomEvent>
197     // say that we should return true for the feature "SVGZoomEvents".
198
199     return true;
200 }
201
202 RefPtr<DocumentType> DOMImplementation::createDocumentType(const String& qualifiedName,
203     const String& publicId, const String& systemId, ExceptionCode& ec)
204 {
205     String prefix, localName;
206     if (!Document::parseQualifiedName(qualifiedName, prefix, localName, ec))
207         return 0;
208
209     return DocumentType::create(m_document, qualifiedName, publicId, systemId);
210 }
211
212 DOMImplementation* DOMImplementation::getInterface(const String& /*feature*/)
213 {
214     return 0;
215 }
216
217 RefPtr<Document> DOMImplementation::createDocument(const String& namespaceURI,
218     const String& qualifiedName, DocumentType* doctype, ExceptionCode& ec)
219 {
220     RefPtr<Document> doc;
221     if (namespaceURI == SVGNames::svgNamespaceURI)
222         doc = SVGDocument::create(0, URL());
223     else if (namespaceURI == HTMLNames::xhtmlNamespaceURI)
224         doc = Document::createXHTML(0, URL());
225     else
226         doc = Document::create(0, URL());
227
228     doc->setSecurityOriginPolicy(m_document.securityOriginPolicy());
229
230     RefPtr<Node> documentElement;
231     if (!qualifiedName.isEmpty()) {
232         documentElement = doc->createElementNS(namespaceURI, qualifiedName, ec);
233         if (ec)
234             return 0;
235     }
236
237     if (doctype)
238         doc->appendChild(*doctype);
239     if (documentElement)
240         doc->appendChild(documentElement.releaseNonNull());
241
242     return doc;
243 }
244
245 Ref<CSSStyleSheet> DOMImplementation::createCSSStyleSheet(const String&, const String& media, ExceptionCode&)
246 {
247     // FIXME: Title should be set.
248     // FIXME: Media could have wrong syntax, in which case we should generate an exception.
249     Ref<CSSStyleSheet> sheet = CSSStyleSheet::create(StyleSheetContents::create());
250     sheet->setMediaQueries(MediaQuerySet::createAllowingDescriptionSyntax(media));
251     return sheet;
252 }
253
254 static inline bool isValidXMLMIMETypeChar(UChar c)
255 {
256     // Valid characters per RFCs 3023 and 2045:
257     // 0-9a-zA-Z_-+~!$^{}|.%'`#&*
258     return isASCIIAlphanumeric(c) || c == '!' || c == '#' || c == '$' || c == '%' || c == '&' || c == '\'' || c == '*' || c == '+'
259         || c == '-' || c == '.' || c == '^' || c == '_' || c == '`' || c == '{' || c == '|' || c == '}' || c == '~';
260 }
261
262 bool DOMImplementation::isXMLMIMEType(const String& mimeType)
263 {
264     if (mimeType == "text/xml" || mimeType == "application/xml" || mimeType == "text/xsl")
265         return true;
266
267     if (!mimeType.endsWith("+xml"))
268         return false;
269
270     size_t slashPosition = mimeType.find('/');
271     // Take into account the '+xml' ending of mimeType.
272     if (slashPosition == notFound || !slashPosition || slashPosition == mimeType.length() - 5)
273         return false;
274
275     // Again, mimeType ends with '+xml', no need to check the validity of that substring.
276     size_t mimeLength = mimeType.length();
277     for (size_t i = 0; i < mimeLength - 4; ++i) {
278         if (!isValidXMLMIMETypeChar(mimeType[i]) && i != slashPosition)
279             return false;
280     }
281
282     return true;
283 }
284
285 bool DOMImplementation::isTextMIMEType(const String& mimeType)
286 {
287     if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(mimeType)
288         || mimeType == "application/json" // Render JSON as text/plain.
289         || (mimeType.startsWith("text/") && mimeType != "text/html"
290             && mimeType != "text/xml" && mimeType != "text/xsl"))
291         return true;
292
293     return false;
294 }
295
296 Ref<HTMLDocument> DOMImplementation::createHTMLDocument(const String& title)
297 {
298     Ref<HTMLDocument> doc = HTMLDocument::create(nullptr, URL());
299     doc->open();
300     doc->write("<!doctype html><html><body></body></html>");
301     if (!title.isNull())
302         doc->setTitle(title);
303     doc->setSecurityOriginPolicy(m_document.securityOriginPolicy());
304     return doc;
305 }
306
307 Ref<Document> DOMImplementation::createDocument(const String& type, Frame* frame, const URL& url)
308 {
309     // Plugins cannot take HTML and XHTML from us, and we don't even need to initialize the plugin database for those.
310     if (type == "text/html")
311         return HTMLDocument::create(frame, url);
312     if (type == "application/xhtml+xml")
313         return Document::createXHTML(frame, url);
314
315 #if ENABLE(FTPDIR)
316     // Plugins cannot take FTP from us either
317     if (type == "application/x-ftp-directory")
318         return FTPDirectoryDocument::create(frame, url);
319 #endif
320
321     // If we want to useImageDocumentForSubframePDF, we'll let that override plugin support.
322     if (frame && !frame->isMainFrame() && MIMETypeRegistry::isPDFMIMEType(type) && frame->settings().useImageDocumentForSubframePDF())
323         return ImageDocument::create(*frame, url);
324
325     PluginData* pluginData = nullptr;
326     PluginData::AllowedPluginTypes allowedPluginTypes = PluginData::OnlyApplicationPlugins;
327     if (frame && frame->page()) {
328         if (frame->loader().subframeLoader().allowPlugins())
329             allowedPluginTypes = PluginData::AllPlugins;
330
331         pluginData = &frame->page()->pluginData();
332     }
333
334     // PDF is one image type for which a plugin can override built-in support.
335     // We do not want QuickTime to take over all image types, obviously.
336     if (MIMETypeRegistry::isPDFOrPostScriptMIMEType(type) && pluginData && pluginData->supportsWebVisibleMimeType(type, allowedPluginTypes))
337         return PluginDocument::create(frame, url);
338     if (Image::supportsType(type))
339         return ImageDocument::create(*frame, url);
340
341 #if ENABLE(VIDEO)
342     // Check to see if the type can be played by our MediaPlayer, if so create a MediaDocument
343     // Key system is not applicable here.
344     DOMImplementationSupportsTypeClient client(frame && frame->settings().needsSiteSpecificQuirks(), url.host());
345     MediaEngineSupportParameters parameters;
346     parameters.type = type;
347     parameters.url = url;
348     if (MediaPlayer::supportsType(parameters, &client))
349         return MediaDocument::create(frame, url);
350 #endif
351
352     // Everything else except text/plain can be overridden by plugins. In particular, Adobe SVG Viewer should be used for SVG, if installed.
353     // Disallowing plug-ins to use text/plain prevents plug-ins from hijacking a fundamental type that the browser is expected to handle,
354     // and also serves as an optimization to prevent loading the plug-in database in the common case.
355     if (type != "text/plain" && ((pluginData && pluginData->supportsWebVisibleMimeType(type, allowedPluginTypes)) || (frame && frame->loader().client().shouldAlwaysUsePluginDocument(type))))
356         return PluginDocument::create(frame, url);
357     if (isTextMIMEType(type))
358         return TextDocument::create(frame, url);
359
360     if (type == "image/svg+xml")
361         return SVGDocument::create(frame, url);
362
363     if (isXMLMIMEType(type))
364         return Document::create(frame, url);
365
366     return HTMLDocument::create(frame, url);
367 }
368
369 }