Teach SubframeLoader a bit about references

https://bugs.webkit.org/show_bug.cgi?id=124076

Reviewed by Anders Carlsson.

* html/HTMLAppletElement.cpp:
* html/HTMLFrameElementBase.cpp:
* html/HTMLMediaElement.cpp:
* loader/SubframeLoader.cpp:
* loader/SubframeLoader.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@158962 268f45cc-cd09-0410-ab3c-d52691b4dbfc

diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
index a7297eb..0a9d98d 100644 (file)
--- a/Source/WebCore/ChangeLog
+++ b/Source/WebCore/ChangeLog
@@ -1,3 +1,16 @@
+2013-11-08  Sam Weinig  <sam@webkit.org>
+
+        Teach SubframeLoader a bit about references
+        https://bugs.webkit.org/show_bug.cgi?id=124076
+
+        Reviewed by Anders Carlsson.
+
+        * html/HTMLAppletElement.cpp:
+        * html/HTMLFrameElementBase.cpp:
+        * html/HTMLMediaElement.cpp:
+        * loader/SubframeLoader.cpp:
+        * loader/SubframeLoader.h:
+
 2013-11-08  Brady Eidson  <beidson@apple.com>
 
         Blind Windows build-fix attempt after r158959

diff --git a/Source/WebCore/html/HTMLAppletElement.cpp b/Source/WebCore/html/HTMLAppletElement.cpp
index 4df7efc..708ca41 100644 (file)
--- a/Source/WebCore/html/HTMLAppletElement.cpp
+++ b/Source/WebCore/html/HTMLAppletElement.cpp
@@ -160,7 +160,7 @@ void HTMLAppletElement::updateWidget(PluginCreationOption pluginCreationOption)
     Frame* frame = document().frame();
     ASSERT(frame);
 
-    renderer->setWidget(frame->loader().subframeLoader().createJavaAppletWidget(roundedIntSize(LayoutSize(contentWidth, contentHeight)), this, paramNames, paramValues));
+    renderer->setWidget(frame->loader().subframeLoader().createJavaAppletWidget(roundedIntSize(LayoutSize(contentWidth, contentHeight)), *this, paramNames, paramValues));
 }
 
 bool HTMLAppletElement::canEmbedJava() const

diff --git a/Source/WebCore/html/HTMLFrameElementBase.cpp b/Source/WebCore/html/HTMLFrameElementBase.cpp
index e2a1f2f..b3dc731 100644 (file)
--- a/Source/WebCore/html/HTMLFrameElementBase.cpp
+++ b/Source/WebCore/html/HTMLFrameElementBase.cpp
@@ -86,7 +86,7 @@ void HTMLFrameElementBase::openURL(bool lockHistory, bool lockBackForwardList)
     if (!parentFrame)
         return;
 
-    parentFrame->loader().subframeLoader().requestFrame(this, m_URL, m_frameName, lockHistory, lockBackForwardList);
+    parentFrame->loader().subframeLoader().requestFrame(*this, m_URL, m_frameName, lockHistory, lockBackForwardList);
     if (contentFrame())
         contentFrame()->setInViewSourceMode(viewSourceMode());
 }

diff --git a/Source/WebCore/html/HTMLMediaElement.cpp b/Source/WebCore/html/HTMLMediaElement.cpp
index 47a1f5a..54d7175 100644 (file)
--- a/Source/WebCore/html/HTMLMediaElement.cpp
+++ b/Source/WebCore/html/HTMLMediaElement.cpp
@@ -4381,7 +4381,7 @@ void HTMLMediaElement::createMediaPlayerProxy()
     
     // Hang onto the proxy widget so it won't be destroyed if the plug-in is set to
     // display:none
-    m_proxyWidget = frame->loader().subframeLoader().loadMediaPlayerProxyPlugin(this, url, paramNames, paramValues);
+    m_proxyWidget = frame->loader().subframeLoader().loadMediaPlayerProxyPlugin(*this, url, paramNames, paramValues);
     if (m_proxyWidget)
         m_needWidgetUpdate = false;
 }
@@ -4398,7 +4398,7 @@ void HTMLMediaElement::updateWidget(PluginCreationOption)
     mediaElement->getPluginProxyParams(kurl, paramNames, paramValues);
     // FIXME: What if document().frame() is 0?
     SubframeLoader& loader = document().frame()->loader().subframeLoader();
-    loader.loadMediaPlayerProxyPlugin(mediaElement, kurl, paramNames, paramValues);
+    loader.loadMediaPlayerProxyPlugin(*mediaElement, kurl, paramNames, paramValues);
 }
 
 #endif // ENABLE(PLUGIN_PROXY_FOR_VIDEO)

diff --git a/Source/WebCore/loader/SubframeLoader.cpp b/Source/WebCore/loader/SubframeLoader.cpp
index 2d202ed..3ecfc8e 100644 (file)
--- a/Source/WebCore/loader/SubframeLoader.cpp
+++ b/Source/WebCore/loader/SubframeLoader.cpp
@@ -75,7 +75,7 @@ void SubframeLoader::clear()
     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;
@@ -106,7 +106,7 @@ bool SubframeLoader::resourceWillUsePlugin(const String& url, const String& mime
     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())
@@ -126,10 +126,10 @@ bool SubframeLoader::pluginIsLoadable(HTMLPlugInImageElement* pluginElement, con
 
         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;
         }
@@ -141,7 +141,7 @@ bool SubframeLoader::pluginIsLoadable(HTMLPlugInImageElement* pluginElement, con
     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
@@ -152,7 +152,7 @@ bool SubframeLoader::requestPlugin(HTMLPlugInImageElement* ownerElement, const U
     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);
 }
 
@@ -221,7 +221,7 @@ bool SubframeLoader::requestObject(HTMLPlugInImageElement& ownerElement, const S
 
     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;
     }
@@ -229,14 +229,13 @@ bool SubframeLoader::requestObject(HTMLPlugInImageElement& ownerElement, const S
     // 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())
@@ -244,26 +243,24 @@ PassRefPtr<Widget> SubframeLoader::loadMediaPlayerProxyPlugin(Node* node, const
 
     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);
@@ -271,11 +268,11 @@ PassRefPtr<Widget> SubframeLoader::loadMediaPlayerProxyPlugin(Node* node, const
     }
     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;
@@ -289,15 +286,15 @@ PassRefPtr<Widget> SubframeLoader::createJavaAppletWidget(const IntSize& size, H
 
     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())
@@ -306,59 +303,59 @@ PassRefPtr<Widget> SubframeLoader::createJavaAppletWidget(const IntSize& size, H
 
     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
@@ -369,7 +366,7 @@ Frame* SubframeLoader::loadSubframe(HTMLFrameOwnerElement* ownerElement, const U
     // 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);
@@ -423,21 +420,19 @@ Document* SubframeLoader::document() const
     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())
@@ -445,7 +440,7 @@ bool SubframeLoader::loadPlugin(HTMLPlugInImageElement* pluginElement, const URL
         return false;
     }
 
-    pluginElement->subframeLoaderDidCreatePlugIn(widget.get());
+    pluginElement.subframeLoaderDidCreatePlugIn(widget.get());
     renderer->setWidget(widget);
     m_containsPlugins = true;
  

diff --git a/Source/WebCore/loader/SubframeLoader.h b/Source/WebCore/loader/SubframeLoader.h
index 9800900..1932ae1 100644 (file)
--- a/Source/WebCore/loader/SubframeLoader.h
+++ b/Source/WebCore/loader/SubframeLoader.h
@@ -45,12 +45,10 @@ class Frame;
 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.
@@ -61,17 +59,15 @@ public:
 
     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);
 
@@ -80,14 +76,13 @@ public:
     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;