m_containsPlugins = false;
}
-bool SubframeLoader::requestFrame(HTMLFrameOwnerElement* ownerElement, const String& urlString, const AtomicString& frameName, bool lockHistory, bool lockBackForwardList)
+bool SubframeLoader::requestFrame(HTMLFrameOwnerElement& ownerElement, const String& urlString, const AtomicString& frameName, bool lockHistory, bool lockBackForwardList)
{
// Support for <frame src="javascript:string">
URL scriptURL;
return shouldUsePlugin(completedURL, mimeType, shouldPreferPlugInsForImages, false, useFallback);
}
-bool SubframeLoader::pluginIsLoadable(HTMLPlugInImageElement* pluginElement, const URL& url, const String& mimeType)
+bool SubframeLoader::pluginIsLoadable(HTMLPlugInImageElement& pluginElement, const URL& url, const String& mimeType)
{
if (MIMETypeRegistry::isJavaAppletMIMEType(mimeType)) {
if (!m_frame.settings().isJavaEnabled())
String declaredMimeType = document()->isPluginDocument() && document()->ownerElement() ?
document()->ownerElement()->fastGetAttribute(HTMLNames::typeAttr) :
- pluginElement->fastGetAttribute(HTMLNames::typeAttr);
+ pluginElement.fastGetAttribute(HTMLNames::typeAttr);
if (!document()->contentSecurityPolicy()->allowObjectFromSource(url)
|| !document()->contentSecurityPolicy()->allowPluginType(mimeType, declaredMimeType, url)) {
- RenderEmbeddedObject* renderer = pluginElement->renderEmbeddedObject();
+ RenderEmbeddedObject* renderer = pluginElement.renderEmbeddedObject();
renderer->setPluginUnavailabilityReason(RenderEmbeddedObject::PluginBlockedByContentSecurityPolicy);
return false;
}
return true;
}
-bool SubframeLoader::requestPlugin(HTMLPlugInImageElement* ownerElement, const URL& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback)
+bool SubframeLoader::requestPlugin(HTMLPlugInImageElement& ownerElement, const URL& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback)
{
// Application plug-ins are plug-ins implemented by the user agent, for example Qt plug-ins,
// as opposed to third-party code such as Flash. The user agent decides whether or not they are
if (!pluginIsLoadable(ownerElement, url, mimeType))
return false;
- ASSERT(ownerElement->hasTagName(objectTag) || ownerElement->hasTagName(embedTag));
+ ASSERT(ownerElement.hasTagName(objectTag) || ownerElement.hasTagName(embedTag));
return loadPlugin(ownerElement, url, mimeType, paramNames, paramValues, useFallback);
}
bool useFallback;
if (shouldUsePlugin(completedURL, mimeType, ownerElement.shouldPreferPlugInsForImages(), hasFallbackContent, useFallback)) {
- bool success = requestPlugin(&ownerElement, completedURL, mimeType, paramNames, paramValues, useFallback);
+ bool success = requestPlugin(ownerElement, completedURL, mimeType, paramNames, paramValues, useFallback);
logPluginRequest(document()->page(), mimeType, completedURL, success);
return success;
}
// If the plug-in element already contains a subframe, loadOrRedirectSubframe will re-use it. Otherwise,
// it will create a new frame and set it as the RenderWidget's Widget, causing what was previously
// in the widget to be torn down.
- return loadOrRedirectSubframe(&ownerElement, completedURL, frameName, true, true);
+ return loadOrRedirectSubframe(ownerElement, completedURL, frameName, true, true);
}
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
-PassRefPtr<Widget> SubframeLoader::loadMediaPlayerProxyPlugin(Node* node, const URL& url,
- const Vector<String>& paramNames, const Vector<String>& paramValues)
+PassRefPtr<Widget> SubframeLoader::loadMediaPlayerProxyPlugin(HTMLMediaElement& mediaElement, const URL& url, const Vector<String>& paramNames, const Vector<String>& paramValues)
{
- ASSERT(node->hasTagName(videoTag) || isHTMLAudioElement(node));
+ ASSERT(mediaElement.hasTagName(videoTag) || isHTMLAudioElement(mediaElement));
URL completedURL;
if (!url.isEmpty())
if (!m_frame.document()->securityOrigin()->canDisplay(completedURL)) {
FrameLoader::reportLocalLoadFailed(m_frame, completedURL.string());
- return 0;
+ return nullptr;
}
if (!m_frame.document()->contentSecurityPolicy()->allowMediaFromSource(completedURL))
- return 0;
+ return nullptr;
- HTMLMediaElement* mediaElement = toHTMLMediaElement(node);
- RenderWidget* renderer = toRenderWidget(node->renderer());
+ RenderWidget* renderer = toRenderWidget(mediaElement.renderer());
IntSize size;
if (renderer)
size = roundedIntSize(LayoutSize(renderer->contentWidth(), renderer->contentHeight()));
- else if (mediaElement->isVideo())
+ else if (mediaElement.isVideo())
size = RenderVideo::defaultSize();
if (!m_frame.loader().mixedContentChecker().canRunInsecureContent(m_frame.document()->securityOrigin(), completedURL))
- return 0;
+ return nullptr;
- RefPtr<Widget> widget = m_frame.loader().client().createMediaPlayerProxyPlugin(size, mediaElement, completedURL,
- paramNames, paramValues, "application/x-media-element-proxy-plugin");
+ RefPtr<Widget> widget = m_frame.loader().client().createMediaPlayerProxyPlugin(size, &mediaElement, completedURL, paramNames, paramValues, "application/x-media-element-proxy-plugin");
if (widget && renderer) {
renderer->setWidget(widget);
}
m_containsPlugins = true;
- return widget ? widget.release() : 0;
+ return widget ? widget.release() : nullptr;
}
#endif // ENABLE(PLUGIN_PROXY_FOR_VIDEO)
-PassRefPtr<Widget> SubframeLoader::createJavaAppletWidget(const IntSize& size, HTMLAppletElement* element, const Vector<String>& paramNames, const Vector<String>& paramValues)
+PassRefPtr<Widget> SubframeLoader::createJavaAppletWidget(const IntSize& size, HTMLAppletElement& element, const Vector<String>& paramNames, const Vector<String>& paramValues)
{
String baseURLString;
String codeBaseURLString;
if (!codeBaseURLString.isEmpty()) {
URL codeBaseURL = completeURL(codeBaseURLString);
- if (!element->document().securityOrigin()->canDisplay(codeBaseURL)) {
+ if (!element.document().securityOrigin()->canDisplay(codeBaseURL)) {
FrameLoader::reportLocalLoadFailed(&m_frame, codeBaseURL.string());
- return 0;
+ return nullptr;
}
const char javaAppletMimeType[] = "application/x-java-applet";
- if (!element->document().contentSecurityPolicy()->allowObjectFromSource(codeBaseURL)
- || !element->document().contentSecurityPolicy()->allowPluginType(javaAppletMimeType, javaAppletMimeType, codeBaseURL))
- return 0;
+ if (!element.document().contentSecurityPolicy()->allowObjectFromSource(codeBaseURL)
+ || !element.document().contentSecurityPolicy()->allowPluginType(javaAppletMimeType, javaAppletMimeType, codeBaseURL))
+ return nullptr;
}
if (baseURLString.isEmpty())
RefPtr<Widget> widget;
if (allowPlugins(AboutToInstantiatePlugin))
- widget = m_frame.loader().client().createJavaAppletWidget(size, element, baseURL, paramNames, paramValues);
+ widget = m_frame.loader().client().createJavaAppletWidget(size, &element, baseURL, paramNames, paramValues);
- logPluginRequest(document()->page(), element->serviceType(), String(), widget);
+ logPluginRequest(document()->page(), element.serviceType(), String(), widget);
if (!widget) {
- RenderEmbeddedObject* renderer = element->renderEmbeddedObject();
+ RenderEmbeddedObject* renderer = element.renderEmbeddedObject();
if (!renderer->isPluginUnavailable())
renderer->setPluginUnavailabilityReason(RenderEmbeddedObject::PluginMissing);
- return 0;
+ return nullptr;
}
m_containsPlugins = true;
return widget;
}
-Frame* SubframeLoader::loadOrRedirectSubframe(HTMLFrameOwnerElement* ownerElement, const URL& url, const AtomicString& frameName, bool lockHistory, bool lockBackForwardList)
+Frame* SubframeLoader::loadOrRedirectSubframe(HTMLFrameOwnerElement& ownerElement, const URL& url, const AtomicString& frameName, bool lockHistory, bool lockBackForwardList)
{
- Frame* frame = ownerElement->contentFrame();
+ Frame* frame = ownerElement.contentFrame();
if (frame)
frame->navigationScheduler().scheduleLocationChange(m_frame.document()->securityOrigin(), url.string(), m_frame.loader().outgoingReferrer(), lockHistory, lockBackForwardList);
else
frame = loadSubframe(ownerElement, url, frameName, m_frame.loader().outgoingReferrer());
- ASSERT(ownerElement->contentFrame() == frame || !ownerElement->contentFrame());
- return ownerElement->contentFrame();
+ ASSERT(ownerElement.contentFrame() == frame || !ownerElement.contentFrame());
+ return ownerElement.contentFrame();
}
-Frame* SubframeLoader::loadSubframe(HTMLFrameOwnerElement* ownerElement, const URL& url, const String& name, const String& referrer)
+Frame* SubframeLoader::loadSubframe(HTMLFrameOwnerElement& ownerElement, const URL& url, const String& name, const String& referrer)
{
Ref<Frame> protect(m_frame);
bool allowsScrolling = true;
int marginWidth = -1;
int marginHeight = -1;
- if (ownerElement->hasTagName(frameTag) || ownerElement->hasTagName(iframeTag)) {
- HTMLFrameElementBase* frameElementBase = toHTMLFrameElementBase(ownerElement);
- allowsScrolling = frameElementBase->scrollingMode() != ScrollbarAlwaysOff;
- marginWidth = frameElementBase->marginWidth();
- marginHeight = frameElementBase->marginHeight();
+ if (ownerElement.hasTagName(frameTag) || ownerElement.hasTagName(iframeTag)) {
+ HTMLFrameElementBase& frameElementBase = toHTMLFrameElementBase(ownerElement);
+ allowsScrolling = frameElementBase.scrollingMode() != ScrollbarAlwaysOff;
+ marginWidth = frameElementBase.marginWidth();
+ marginHeight = frameElementBase.marginHeight();
}
- if (!ownerElement->document().securityOrigin()->canDisplay(url)) {
+ if (!ownerElement.document().securityOrigin()->canDisplay(url)) {
FrameLoader::reportLocalLoadFailed(&m_frame, url.string());
- return 0;
+ return nullptr;
}
- String referrerToUse = SecurityPolicy::generateReferrerHeader(ownerElement->document().referrerPolicy(), url, referrer);
- RefPtr<Frame> frame = m_frame.loader().client().createFrame(url, name, ownerElement, referrerToUse, allowsScrolling, marginWidth, marginHeight);
+ String referrerToUse = SecurityPolicy::generateReferrerHeader(ownerElement.document().referrerPolicy(), url, referrer);
+ RefPtr<Frame> frame = m_frame.loader().client().createFrame(url, name, &ownerElement, referrerToUse, allowsScrolling, marginWidth, marginHeight);
if (!frame) {
m_frame.loader().checkCallImplicitClose();
- return 0;
+ return nullptr;
}
// All new frames will have m_isComplete set to true at this point due to synchronously loading
// FIXME: Can we remove this entirely? m_isComplete normally gets set to false when a load is committed.
frame->loader().started();
- RenderObject* renderer = ownerElement->renderer();
+ RenderObject* renderer = ownerElement.renderer();
FrameView* view = frame->view();
if (renderer && renderer->isWidget() && view)
toRenderWidget(renderer)->setWidget(view);
return m_frame.document();
}
-bool SubframeLoader::loadPlugin(HTMLPlugInImageElement* pluginElement, const URL& url, const String& mimeType,
- const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback)
+bool SubframeLoader::loadPlugin(HTMLPlugInImageElement& pluginElement, const URL& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback)
{
- RenderEmbeddedObject* renderer = pluginElement->renderEmbeddedObject();
+ RenderEmbeddedObject* renderer = pluginElement.renderEmbeddedObject();
// FIXME: This code should not depend on renderer!
if (!renderer || useFallback)
return false;
- pluginElement->subframeLoaderWillCreatePlugIn(url);
+ pluginElement.subframeLoaderWillCreatePlugIn(url);
IntSize contentSize = roundedIntSize(LayoutSize(renderer->contentWidth(), renderer->contentHeight()));
bool loadManually = document()->isPluginDocument() && !m_containsPlugins && toPluginDocument(document())->shouldLoadPluginManually();
- RefPtr<Widget> widget = m_frame.loader().client().createPlugin(contentSize,
- pluginElement, url, paramNames, paramValues, mimeType, loadManually);
+ RefPtr<Widget> widget = m_frame.loader().client().createPlugin(contentSize, &pluginElement, url, paramNames, paramValues, mimeType, loadManually);
if (!widget) {
if (!renderer->isPluginUnavailable())
return false;
}
- pluginElement->subframeLoaderDidCreatePlugIn(widget.get());
+ pluginElement.subframeLoaderDidCreatePlugIn(widget.get());
renderer->setWidget(widget);
m_containsPlugins = true;
class FrameLoaderClient;
class HTMLAppletElement;
class HTMLFrameOwnerElement;
+class HTMLMediaElement;
class HTMLPlugInImageElement;
class IntSize;
class URL;
-#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
-class Node;
-#endif
class Widget;
// This is a slight misnomer. It handles the higher level logic of loading both subframes and plugins.
void clear();
- bool requestFrame(HTMLFrameOwnerElement*, const String& url, const AtomicString& frameName, bool lockHistory = true, bool lockBackForwardList = true);
+ bool requestFrame(HTMLFrameOwnerElement&, const String& url, const AtomicString& frameName, bool lockHistory = true, bool lockBackForwardList = true);
bool requestObject(HTMLPlugInImageElement&, const String& url, const AtomicString& frameName,
const String& serviceType, const Vector<String>& paramNames, const Vector<String>& paramValues);
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
- // FIXME: This should take Element* instead of Node*, or better yet the
- // specific type of Element which this code depends on.
- PassRefPtr<Widget> loadMediaPlayerProxyPlugin(Node*, const URL&, const Vector<String>& paramNames, const Vector<String>& paramValues);
+ PassRefPtr<Widget> loadMediaPlayerProxyPlugin(HTMLMediaElement&, const URL&, const Vector<String>& paramNames, const Vector<String>& paramValues);
#endif
- PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const Vector<String>& paramNames, const Vector<String>& paramValues);
+ PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement&, const Vector<String>& paramNames, const Vector<String>& paramValues);
bool allowPlugins(ReasonForCallingAllowPlugins);
bool resourceWillUsePlugin(const String& url, const String& mimeType, bool shouldPreferPlugInsForImages);
private:
- bool requestPlugin(HTMLPlugInImageElement*, const URL&, const String& serviceType, const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback);
- Frame* loadOrRedirectSubframe(HTMLFrameOwnerElement*, const URL&, const AtomicString& frameName, bool lockHistory, bool lockBackForwardList);
- Frame* loadSubframe(HTMLFrameOwnerElement*, const URL&, const String& name, const String& referrer);
- bool loadPlugin(HTMLPlugInImageElement*, const URL&, const String& mimeType,
- const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback);
+ bool requestPlugin(HTMLPlugInImageElement&, const URL&, const String& serviceType, const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback);
+ Frame* loadOrRedirectSubframe(HTMLFrameOwnerElement&, const URL&, const AtomicString& frameName, bool lockHistory, bool lockBackForwardList);
+ Frame* loadSubframe(HTMLFrameOwnerElement&, const URL&, const String& name, const String& referrer);
+ bool loadPlugin(HTMLPlugInImageElement&, const URL&, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback);
bool shouldUsePlugin(const URL&, const String& mimeType, bool shouldPreferPlugInsForImages, bool hasFallback, bool& useFallback);
- bool pluginIsLoadable(HTMLPlugInImageElement*, const URL&, const String& mimeType);
+ bool pluginIsLoadable(HTMLPlugInImageElement&, const URL&, const String& mimeType);
Document* document() const;