PassRefPtr<Document> DOMImplementation::createDocument(const String& type, Frame* frame, bool inViewSourceMode)
{
if (inViewSourceMode) {
if (type == "text/html" || type == "application/xhtml+xml" || type == "image/svg+xml" || isTextMIMEType(type) || isXMLMIMEType(type))
return HTMLViewSourceDocument::create(frame, type);
}
// Plugins cannot take HTML and XHTML from us, and we don't even need to initialize the plugin database for those.
if (type == "text/html")
return HTMLDocument::create(frame);
if (type == "application/xhtml+xml")
return Document::createXHTML(frame);
#if ENABLE(FTPDIR)
// Plugins cannot take FTP from us either
if (type == "application/x-ftp-directory")
return FTPDirectoryDocument::create(frame);
#endif
PluginData* pluginData = 0;
if (frame && frame->page() && frame->page()->settings()->arePluginsEnabled())
pluginData = frame->page()->pluginData();
// PDF is one image type for which a plugin can override built-in support.
// We do not want QuickTime to take over all image types, obviously.
if ((type == "application/pdf" || type == "text/pdf") && pluginData && pluginData->supportsMimeType(type))
return PluginDocument::create(frame);
if (Image::supportsType(type))
return ImageDocument::create(frame);
#if ENABLE(VIDEO)
// Check to see if the type can be played by our MediaPlayer, if so create a MediaDocument
if (MediaPlayer::supportsType(type))
return MediaDocument::create(frame);
#endif
// Everything else except text/plain can be overridden by plugins. In particular, Adobe SVG Viewer should be used for SVG, if installed.
// Disallowing plug-ins to use text/plain prevents plug-ins from hijacking a fundamental type that the browser is expected to handle,
// and also serves as an optimization to prevent loading the plug-in database in the common case.
if (type != "text/plain" && pluginData && pluginData->supportsMimeType(type))
return PluginDocument::create(frame);
if (isTextMIMEType(type))
return TextDocument::create(frame);
#if ENABLE(SVG)
if (type == "image/svg+xml") {
#if ENABLE(DASHBOARD_SUPPORT)
Settings* settings = frame ? frame->settings() : 0;
if (!settings || !settings->usesDashboardBackwardCompatibilityMode())
#endif
return SVGDocument::create(frame);
}
#endif
if (isXMLMIMEType(type))
return Document::create(frame);
return HTMLDocument::create(frame);
}
PassRefPtr<Document> DOMImplementation::createDocument(const String& type, Frame* frame, const URL& url)
{
// Plugins cannot take HTML and XHTML from us, and we don't even need to initialize the plugin database for those.
if (type == "text/html")
return HTMLDocument::create(frame, url);
if (type == "application/xhtml+xml")
return Document::createXHTML(frame, url);
#if ENABLE(FTPDIR)
// Plugins cannot take FTP from us either
if (type == "application/x-ftp-directory")
return FTPDirectoryDocument::create(frame, url);
#endif
PluginData* pluginData = 0;
PluginData::AllowedPluginTypes allowedPluginTypes = PluginData::OnlyApplicationPlugins;
if (frame && frame->page()) {
if (frame->loader().subframeLoader().allowPlugins(NotAboutToInstantiatePlugin))
allowedPluginTypes = PluginData::AllPlugins;
pluginData = &frame->page()->pluginData();
}
// PDF is one image type for which a plugin can override built-in support.
// We do not want QuickTime to take over all image types, obviously.
if ((MIMETypeRegistry::isPDFOrPostScriptMIMEType(type)) && pluginData && pluginData->supportsMimeType(type, allowedPluginTypes))
return PluginDocument::create(frame, url);
if (Image::supportsType(type))
return ImageDocument::create(frame, url);
#if ENABLE(VIDEO) && !ENABLE(PLUGIN_PROXY_FOR_VIDEO)
// Check to see if the type can be played by our MediaPlayer, if so create a MediaDocument
// Key system is not applicable here.
DOMImplementationSupportsTypeClient client(frame && frame->settings().needsSiteSpecificQuirks(), url.host());
MediaEngineSupportParameters parameters;
parameters.type = type;
parameters.url = url;
if (MediaPlayer::supportsType(parameters, &client))
return MediaDocument::create(frame, url);
#endif
// Everything else except text/plain can be overridden by plugins. In particular, Adobe SVG Viewer should be used for SVG, if installed.
// Disallowing plug-ins to use text/plain prevents plug-ins from hijacking a fundamental type that the browser is expected to handle,
// and also serves as an optimization to prevent loading the plug-in database in the common case.
if (type != "text/plain" && ((pluginData && pluginData->supportsMimeType(type, allowedPluginTypes)) || (frame && frame->loader().client().shouldAlwaysUsePluginDocument(type))))
return PluginDocument::create(frame, url);
if (isTextMIMEType(type))
return TextDocument::create(frame, url);
if (type == "image/svg+xml")
return SVGDocument::create(frame, url);
if (isXMLMIMEType(type))
return Document::create(frame, url);
return HTMLDocument::create(frame, url);
}
static bool canShowMIMEType(const String& mimeType, Page* page)
{
if (blink::Platform::current()->mimeRegistry()->supportsMIMEType(mimeType) == blink::WebMimeRegistry::IsSupported)
return true;
PluginData* pluginData = page->pluginData();
return !mimeType.isEmpty() && pluginData && pluginData->supportsMimeType(mimeType);
}
static bool canShowMIMEType(const String& mimeType, LocalFrame* frame)
{
if (Platform::current()->mimeRegistry()->supportsMIMEType(mimeType) == WebMimeRegistry::IsSupported)
return true;
PluginData* pluginData = frame->pluginData();
return !mimeType.isEmpty() && pluginData && pluginData->supportsMimeType(mimeType);
}
PassRefPtr<Document> DOMImplementation::createDocument(const String& type, Frame* frame, const KURL& url, bool inViewSourceMode)
{
if (inViewSourceMode)
return HTMLViewSourceDocument::create(frame, url, type);
// Plugins cannot take HTML and XHTML from us, and we don't even need to initialize the plugin database for those.
if (type == "text/html")
return HTMLDocument::create(frame, url);
if (type == "application/xhtml+xml")
return Document::createXHTML(frame, url);
PluginData* pluginData = 0;
if (frame && frame->page() && frame->loader()->subframeLoader()->allowPlugins(NotAboutToInstantiatePlugin))
pluginData = frame->page()->pluginData();
// PDF is one image type for which a plugin can override built-in support.
// We do not want QuickTime to take over all image types, obviously.
if ((type == "application/pdf" || type == "text/pdf") && pluginData && pluginData->supportsMimeType(type))
return PluginDocument::create(frame, url);
if (Image::supportsType(type))
return ImageDocument::create(frame, url);
// Check to see if the type can be played by our MediaPlayer, if so create a MediaDocument
// Key system is not applicable here.
if (MediaPlayer::supportsType(ContentType(type), String(), url))
return MediaDocument::create(frame, url);
// Everything else except text/plain can be overridden by plugins. In particular, Adobe SVG Viewer should be used for SVG, if installed.
// Disallowing plug-ins to use text/plain prevents plug-ins from hijacking a fundamental type that the browser is expected to handle,
// and also serves as an optimization to prevent loading the plug-in database in the common case.
if (type != "text/plain" && pluginData && pluginData->supportsMimeType(type))
return PluginDocument::create(frame, url);
if (isTextMIMEType(type))
return TextDocument::create(frame, url);
#if ENABLE(SVG)
if (type == "image/svg+xml")
return SVGDocument::create(frame, url);
#endif
if (isXMLMIMEType(type))
return Document::create(frame, url);
return HTMLDocument::create(frame, url);
}
PassRefPtrWillBeRawPtr<Document> DOMImplementation::createDocument(const String& type, const DocumentInit& init, bool inViewSourceMode)
{
if (inViewSourceMode)
return HTMLViewSourceDocument::create(init, type);
// Plugins cannot take HTML and XHTML from us, and we don't even need to initialize the plugin database for those.
if (type == "text/html")
return HTMLDocument::create(init);
if (type == "application/xhtml+xml" || type == "application/vnd.wap.xhtml+xml")
return XMLDocument::createXHTML(init);
if (type == "text/vnd.wap.wml")
return XMLDocument::createWML(init);
PluginData* pluginData = 0;
if (init.frame() && init.frame()->page() && init.frame()->loader().allowPlugins(NotAboutToInstantiatePlugin))
pluginData = init.frame()->page()->pluginData();
// PDF is one image type for which a plugin can override built-in support.
// We do not want QuickTime to take over all image types, obviously.
if ((type == "application/pdf" || type == "text/pdf") && pluginData && pluginData->supportsMimeType(type))
return PluginDocument::create(init);
if (Image::supportsType(type))
return ImageDocument::create(init);
// Check to see if the type can be played by our media player, if so create a MediaDocument
if (HTMLMediaElement::supportsType(ContentType(type)))
return MediaDocument::create(init);
// Everything else except text/plain can be overridden by plugins. In particular, Adobe SVG Viewer should be used for SVG, if installed.
// Disallowing plugins to use text/plain prevents plugins from hijacking a fundamental type that the browser is expected to handle,
// and also serves as an optimization to prevent loading the plugin database in the common case.
if (type != "text/plain" && pluginData && pluginData->supportsMimeType(type))
return PluginDocument::create(init);
if (isTextMIMEType(type))
return TextDocument::create(init);
if (type == "image/svg+xml")
return XMLDocument::createSVG(init);
if (isXMLMIMEType(type))
return XMLDocument::create(init);
return HTMLDocument::create(init);
}
ObjectContentType FrameLoaderClientImpl::getObjectContentType(
const KURL& url,
const String& explicitMimeType,
bool shouldPreferPlugInsForImages) {
// This code is based on Apple's implementation from
// WebCoreSupport/WebFrameBridge.mm.
String mimeType = explicitMimeType;
if (mimeType.isEmpty()) {
// Try to guess the MIME type based off the extension.
String filename = url.lastPathComponent();
int extensionPos = filename.reverseFind('.');
if (extensionPos >= 0) {
String extension = filename.substring(extensionPos + 1);
mimeType = MIMETypeRegistry::getWellKnownMIMETypeForExtension(extension);
}
if (mimeType.isEmpty())
return ObjectContentFrame;
}
// If Chrome is started with the --disable-plugins switch, pluginData is 0.
PluginData* pluginData = m_webFrame->frame()->pluginData();
bool plugInSupportsMIMEType =
pluginData && pluginData->supportsMimeType(mimeType);
if (MIMETypeRegistry::isSupportedImageMIMEType(mimeType))
return shouldPreferPlugInsForImages && plugInSupportsMIMEType
? ObjectContentNetscapePlugin
: ObjectContentImage;
if (plugInSupportsMIMEType)
return ObjectContentNetscapePlugin;
if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType))
return ObjectContentFrame;
return ObjectContentNone;
}
