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