static String findPluginMIMETypeFromURL(Page* page, const String& url)
{
if (!url)
return String();
size_t dotIndex = url.reverseFind('.');
if (dotIndex == notFound)
return String();
String extension = url.substring(dotIndex + 1);
PluginData* pluginData = page->pluginData();
if (!pluginData)
return String();
for (size_t i = 0; i < pluginData->mimes().size(); ++i) {
const MimeClassInfo& mimeClassInfo = pluginData->mimes()[i];
for (size_t j = 0; j < mimeClassInfo.extensions.size(); ++j) {
if (equalIgnoringCase(extension, mimeClassInfo.extensions[j]))
return mimeClassInfo.type;
}
}
return String();
}
static void logPluginRequest(Page* page, const String& mimeType, const String& url, bool success)
{
if (!page || !page->settings()->diagnosticLoggingEnabled())
return;
String newMIMEType = mimeType;
if (!newMIMEType) {
// Try to figure out the MIME type from the URL extension.
newMIMEType = findPluginMIMETypeFromURL(page, url);
if (!newMIMEType)
return;
}
PluginData* pluginData = page->pluginData();
String pluginFile = pluginData ? pluginData->pluginFileForMimeType(newMIMEType) : String();
String description = !pluginFile ? newMIMEType : pluginFile;
ChromeClient* client = page->chrome().client();
client->logDiagnosticMessage(success ? DiagnosticLoggingKeys::pluginLoadedKey() : DiagnosticLoggingKeys::pluginLoadingFailedKey(), description, DiagnosticLoggingKeys::noopKey());
if (!page->hasSeenAnyPlugin())
client->logDiagnosticMessage(DiagnosticLoggingKeys::pageContainsAtLeastOnePluginKey(), emptyString(), DiagnosticLoggingKeys::noopKey());
if (!page->hasSeenPlugin(description))
client->logDiagnosticMessage(DiagnosticLoggingKeys::pageContainsPluginKey(), description, DiagnosticLoggingKeys::noopKey());
page->sawPlugin(description);
}
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);
}
unsigned DOMPluginArray::length() const
{
PluginData* data = pluginData();
if (!data)
return 0;
return data->plugins().size();
}
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);
}
unsigned DOMMimeTypeArray::length() const
{
PluginData* data = getPluginData();
if (!data)
return 0;
return data->mimes().size();
}
void WelcomeWindow::quitPlugin() {
//Unloads and disables the plugin
//We don't want the welcome plugin at every QuarkPlayer start
//just at the very first start
PluginData pluginData = PluginManager::instance().pluginData(uuid());
pluginData.setEnabled(false);
PluginManager::instance().deletePlugin(pluginData);
}
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);
}
DOMMimeType* DOMMimeTypeArray::item(unsigned index) {
PluginData* data = getPluginData();
if (!data)
return nullptr;
const Vector<MimeClassInfo>& mimes = data->mimes();
if (index >= mimes.size())
return nullptr;
return DOMMimeType::create(data, frame(), index);
}
PassRefPtr<MimeType> MimeTypeArray::item(unsigned index)
{
PluginData* data = getPluginData();
if (!data)
return 0;
const Vector<MimeClassInfo*>& mimes = data->mimes();
if (index >= mimes.size())
return 0;
return MimeType::create(data, index).get();
}
PassRefPtrWillBeRawPtr<DOMMimeType> DOMMimeTypeArray::item(unsigned index)
{
PluginData* data = getPluginData();
if (!data)
return nullptr;
const Vector<MimeClassInfo>& mimes = data->mimes();
if (index >= mimes.size())
return nullptr;
return DOMMimeType::create(data, m_frame, index).get();
}
PassRefPtrWillBeRawPtr<DOMPlugin> DOMPluginArray::item(unsigned index)
{
PluginData* data = pluginData();
if (!data)
return nullptr;
const Vector<PluginInfo>& plugins = data->plugins();
if (index >= plugins.size())
return nullptr;
return DOMPlugin::create(data, m_frame, index).get();
}
DOMMimeType* DOMMimeTypeArray::namedItem(const AtomicString& propertyName) {
PluginData* data = getPluginData();
if (!data)
return nullptr;
const Vector<MimeClassInfo>& mimes = data->mimes();
for (unsigned i = 0; i < mimes.size(); ++i) {
if (mimes[i].type == propertyName)
return DOMMimeType::create(data, frame(), i);
}
return nullptr;
}
unsigned DOMMimeTypeArray::length() const
{
PluginData* data = getPluginData();
if (!data)
return 0;
Vector<MimeClassInfo> mimes;
Vector<size_t> mimePluginIndices;
data->getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
return mimes.size();
}
PassRefPtr<MimeType> MimeTypeArray::namedItem(const AtomicString& propertyName)
{
PluginData *data = getPluginData();
if (!data)
return 0;
const Vector<MimeClassInfo*>& mimes = data->mimes();
for (unsigned i = 0; i < mimes.size(); ++i) {
if (mimes[i]->type == propertyName)
return MimeType::create(data, i).get();
}
return 0;
}
bool DOMPluginArray::canGetItemsForName(const AtomicString& propertyName)
{
PluginData* data = pluginData();
if (!data)
return 0;
const Vector<PluginInfo>& plugins = data->plugins();
for (unsigned i = 0; i < plugins.size(); ++i) {
if (plugins[i].name == propertyName)
return true;
}
return false;
}
PassRefPtrWillBeRawPtr<DOMPlugin> DOMPluginArray::namedItem(const AtomicString& propertyName)
{
PluginData* data = pluginData();
if (!data)
return nullptr;
const Vector<PluginInfo>& plugins = data->plugins();
for (unsigned i = 0; i < plugins.size(); ++i) {
if (plugins[i].name == propertyName)
return DOMPlugin::create(data, m_frame, i).get();
}
return nullptr;
}
bool DOMMimeTypeArray::canGetItemsForName(const AtomicString& propertyName)
{
PluginData *data = getPluginData();
if (!data)
return 0;
const Vector<MimeClassInfo>& mimes = data->mimes();
for (unsigned i = 0; i < mimes.size(); ++i) {
if (mimes[i].type == propertyName)
return true;
}
return false;
}
PassRefPtr<DOMMimeType> DOMMimeTypeArray::item(unsigned index)
{
PluginData* data = getPluginData();
if (!data)
return 0;
Vector<MimeClassInfo> mimes;
Vector<size_t> mimePluginIndices;
data->getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
if (index >= mimes.size())
return 0;
return DOMMimeType::create(data, m_frame, index);
}
bool DOMMimeTypeArray::canGetItemsForName(const AtomicString& propertyName)
{
PluginData *data = getPluginData();
if (!data)
return 0;
Vector<MimeClassInfo> mimes;
Vector<size_t> mimePluginIndices;
data->getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
for (auto& mime : mimes) {
if (mime.type == propertyName)
return true;
}
return false;
}
PassRefPtr<DOMMimeType> DOMMimeTypeArray::namedItem(const AtomicString& propertyName)
{
PluginData *data = getPluginData();
if (!data)
return 0;
Vector<MimeClassInfo> mimes;
Vector<size_t> mimePluginIndices;
data->getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
for (unsigned i = 0; i < mimes.size(); ++i) {
if (mimes[i].type == propertyName)
return DOMMimeType::create(data, m_frame, i);
}
return 0;
}
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;
}
