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; }