BrowserPlugin/WebView - Move plugin lifetime to DOM

Source/core/html/HTMLPlugInElement.cpp

 /**
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Stefan Schimanski (1Stein@gmx.de)
  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 64 matching lines @@
     ASSERT(!m_pluginWrapper); // cleared in detach()
 
     if (m_NPObject) {
         _NPN_ReleaseObject(m_NPObject);
         m_NPObject = 0;
     }
 }
 
 bool HTMLPlugInElement::canProcessDrag() const
 {
-    return pluginWidget() && pluginWidget()->isPluginView() && toPluginView(pluginWidget())->canProcessDrag();
+    return widget() && widget()->isPluginView() && toPluginView(widget())->canProcessDrag();
 }
 
 bool HTMLPlugInElement::willRespondToMouseClickEvents()
 {
     if (isDisabledFormControl())
         return false;
     RenderObject* r = renderer();
     return r && (r->isEmbeddedObject() || r->isWidget());
 }
 
@@ skipping 33 matching lines @@
 {
     toHTMLPlugInElement(n)->updateWidgetIfNecessary();
 }
 
 void HTMLPlugInElement::updateWidgetIfNecessary()
 {
     document().updateStyleIfNeeded();
 
     if (!needsWidgetUpdate() || useFallbackContent() || isImageType())
         return;
+
+    if (!renderEmbeddedObject() && !m_serviceType.isEmpty()) {
+        createPluginWithoutRenderer(m_serviceType);
+        return;
+    }
+
     if (!renderEmbeddedObject() || renderEmbeddedObject()->showsUnavailablePluginIndicator())
         return;
 
     updateWidget(CreateOnlyNonNetscapePlugins);
 }
 
+void HTMLPlugInElement::createPluginWithoutRenderer(const String& mimeType)
+{
+    KURL url;
+    Vector<String> paramNames;
+    Vector<String> paramValues;
+
+    paramNames.append("type");
+    paramValues.append(mimeType);
+
+    bool useFallback = false;
+    if (loadPlugin(url, mimeType, paramNames, paramValues, useFallback)) {
+        // Register the bindings with V8 as a scriptable object; normally this
+        // as done in getInstance(), but that is only called after a renderer
+        // has been assigned.
+        // If we've created a plugin without a renderer, it may want to be able
+        // to configure itself before attach, so make sure it has a script
+        // object.
+        // FIXME: Do we need a new script object and plugin wrapper when we
+        // create a plugin? Or can we re-use any existing ones?
+        Widget* plugin = widget();
+        ASSERT(plugin);
+        Frame* frame = document().frame();
+        if (!m_NPObject)
+            m_NPObject = frame->script().createScriptObjectForPluginElement(this);
+        m_pluginWrapper = frame->script().createPluginWrapper(plugin);
+    }
+}
+
 void HTMLPlugInElement::detach(const AttachContext& context)
 {
     // Update the widget the next time we attach (detaching destroys the plugin).
     // FIXME: None of this "needsWidgetUpdate" related code looks right.
     if (renderer() && !useFallbackContent())
         setNeedsWidgetUpdate(true);
 
-    resetInstance();
+    Widget* plugin = widget();
+    if (plugin) {

[eseidel, 2013/12/02 16:28:34]

Just combine these two ifs into one line?

[wjmaclean, 2013/12/02 21:51:55]

This disappears in the new patch :-)

+        if (!plugin->pluginShouldPersist()) {
+            setWidget(0);
+            resetInstance();
+        }
+    }
 
     if (m_isCapturingMouseEvents) {
         if (Frame* frame = document().frame())
             frame->eventHandler().setCapturingMouseEventsNode(0);
         m_isCapturingMouseEvents = false;
     }
 
     if (m_NPObject) {
         _NPN_ReleaseObject(m_NPObject);
         m_NPObject = 0;
@@ skipping 45 matching lines @@
 SharedPersistent<v8::Object>* HTMLPlugInElement::pluginWrapper()
 {
     Frame* frame = document().frame();
     if (!frame)
         return 0;
 
     // If the host dynamically turns off JavaScript (or Java) we will still
     // return the cached allocated Bindings::Instance. Not supporting this
     // edge-case is OK.
     if (!m_pluginWrapper) {
-        if (Widget* widget = pluginWidget())
-            m_pluginWrapper = frame->script().createPluginWrapper(widget);
+        if (Widget* plugin = widget())
+            m_pluginWrapper = frame->script().createPluginWrapper(plugin);
     }
     return m_pluginWrapper.get();
 }
 
 bool HTMLPlugInElement::dispatchBeforeLoadEvent(const String& sourceURL)
 {
     // FIXME: Our current plug-in loading design can't guarantee the following
     // assertion is true, since plug-in loading can be initiated during layout,
     // and synchronous layout can be initiated in a beforeload event handler!
     // See <http://webkit.org/b/71264>.
     // ASSERT(!m_inBeforeLoadEventHandler);
     m_inBeforeLoadEventHandler = true;
     bool beforeLoadAllowedLoad = HTMLFrameOwnerElement::dispatchBeforeLoadEvent(sourceURL);
     m_inBeforeLoadEventHandler = false;
     return beforeLoadAllowedLoad;
 }
 
-Widget* HTMLPlugInElement::pluginWidget() const
-{
-    if (m_inBeforeLoadEventHandler) {
-        // The plug-in hasn't loaded yet, and it makes no sense to try to load
-        // if beforeload handler happened to touch the plug-in element. That
-        // would recursively call beforeload for the same element.
-        return 0;
-    }
-
-    if (RenderWidget* renderWidget = renderWidgetForJSBindings())
-        return renderWidget->widget();
-    return 0;
-}
-
 bool HTMLPlugInElement::isPresentationAttribute(const QualifiedName& name) const
 {
     if (name == widthAttr || name == heightAttr || name == vspaceAttr || name == hspaceAttr || name == alignAttr)
         return true;
     return HTMLFrameOwnerElement::isPresentationAttribute(name);
 }
 
 void HTMLPlugInElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStylePropertySet* style)
 {
     if (name == widthAttr) {
@@ skipping 49 matching lines @@
     // when JavaScript code accesses the plugin.
     // FIXME: Check if dispatching events here is safe.
     document().updateLayoutIgnorePendingStylesheets(Document::RunPostLayoutTasksSynchronously);
     return existingRenderWidget();
 }
 
 bool HTMLPlugInElement::isKeyboardFocusable() const
 {
     if (!document().page())
         return false;
-    return pluginWidget() && pluginWidget()->isPluginView() && toPluginView(pluginWidget())->supportsKeyboardFocus();
+    return widget() && widget()->isPluginView() && toPluginView(widget())->supportsKeyboardFocus();
 }
 
 bool HTMLPlugInElement::isPluginElement() const
 {
     return true;
 }
 
 bool HTMLPlugInElement::rendererIsFocusable() const
 {
     if (HTMLFrameOwnerElement::supportsFocus() && HTMLFrameOwnerElement::rendererIsFocusable())
@@ skipping 91 matching lines @@
 bool HTMLPlugInElement::loadPlugin(const KURL& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback)
 {
     Frame* frame = document().frame();
 
     if (!frame->loader().allowPlugins(AboutToInstantiatePlugin))
         return false;
 
     if (!pluginIsLoadable(url, mimeType))
         return false;
 
+    bool canCreateWithoutRenderer = frame->loader().client()->canCreatePluginWithoutRenderer(mimeType);
+
     RenderEmbeddedObject* renderer = renderEmbeddedObject();
     // FIXME: This code should not depend on renderer!
-    if (!renderer || useFallback)
+    if ((!renderer && !canCreateWithoutRenderer) || useFallback)
         return false;
 
+    FrameLoaderClient::PluginLoadType loadType = renderer ? FrameLoaderClient::PluginLoadRequiresRenderer : FrameLoaderClient::PluginLoadWithoutRenderer;
+
     LOG(Plugins, "%p Plug-in URL: %s", this, m_url.utf8().data());
     LOG(Plugins, "   Loaded URL: %s", url.string().utf8().data());
     m_loadedUrl = url;
 
-    IntSize contentSize = roundedIntSize(LayoutSize(renderer->contentWidth(), renderer->contentHeight()));
-    bool loadManually = document().isPluginDocument() && !document().containsPlugins() && toPluginDocument(document()).shouldLoadPluginManually();
-    RefPtr<Widget> widget = frame->loader().client()->createPlugin(contentSize, this, url, paramNames, paramValues, mimeType, loadManually);
+    IntSize contentSize;
+    if (renderer)
+        contentSize = roundedIntSize(LayoutSize(renderer->contentWidth(), renderer->contentHeight()));
+    RefPtr<Widget> plugin = widget();
 
-    if (!widget) {
-        if (!renderer->showsUnavailablePluginIndicator())
+    if (!plugin) {
+        bool loadManually = document().isPluginDocument() && !document().containsPlugins() && toPluginDocument(document()).shouldLoadPluginManually();
+        plugin = frame->loader().client()->createPlugin(contentSize, this, url, paramNames, paramValues, mimeType, loadManually, loadType);
+    }
+
+    if (!plugin) {
+        if (renderer && !renderer->showsUnavailablePluginIndicator())
             renderer->setPluginUnavailabilityReason(RenderEmbeddedObject::PluginMissing);
         return false;
     }
 
-    renderer->setWidget(widget);
+    ASSERT(plugin->isPluginContainer());
+    setWidget(plugin);
+
+    if (renderer) {
+        // FIXME: We assume we don't layout without a renderer, but check this assumption.

[eseidel, 2013/12/02 16:28:34]

style recalc creates/destroys renderers.  I doubt you need to check (renderer)
here.

[wjmaclean, 2013/12/02 21:51:55]

Thanks, that's useful to know. I'll remove the if() and re-test the cl.

+        setNeedsStyleRecalc(LocalStyleChange, StyleChangeFromRenderer);
+    }
     document().setContainsPlugins();
-    setNeedsStyleRecalc(LocalStyleChange, StyleChangeFromRenderer);
     return true;
 }
 
 bool HTMLPlugInElement::shouldUsePlugin(const KURL& url, const String& mimeType, bool hasFallback, bool& useFallback)
 {
     // Allow other plug-ins to win over QuickTime because if the user has
     // installed a plug-in that can handle TIFF (which QuickTime can also
     // handle) they probably intended to override QT.
     if (document().frame()->page() && (mimeType == "image/tiff" || mimeType == "image/tif" || mimeType == "image/x-tiff")) {
         const PluginData* pluginData = document().frame()->page()->pluginData();
@@ skipping 34 matching lines @@
     if (!document().contentSecurityPolicy()->allowObjectFromSource(url)
         || !document().contentSecurityPolicy()->allowPluginType(mimeType, declaredMimeType, url)) {
         renderEmbeddedObject()->setPluginUnavailabilityReason(RenderEmbeddedObject::PluginBlockedByContentSecurityPolicy);
         return false;
     }
 
     return frame->loader().mixedContentChecker()->canRunInsecureContent(document().securityOrigin(), url);
 }
 
 }