Blink Plugins: Remove Shadow DOM Plugin Placeholder

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 29 matching lines @@
 #include "core/html/PluginDocument.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutEmbeddedObject.h"
 #include "core/layout/LayoutImage.h"
 #include "core/layout/LayoutPart.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/loader/MixedContentChecker.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
-#include "core/plugins/PluginPlaceholder.h"
 #include "core/plugins/PluginView.h"
 #include "platform/Logging.h"
 #include "platform/MIMETypeFromURL.h"
 #include "platform/MIMETypeRegistry.h"
 #include "platform/Widget.h"
 #include "platform/plugins/PluginData.h"
 #include "public/platform/WebURLRequest.h"
 
 namespace blink {
 
@@ skipping 19 matching lines @@
 
     if (m_NPObject) {
         _NPN_ReleaseObject(m_NPObject);
         m_NPObject = 0;
     }
 }
 
 DEFINE_TRACE(HTMLPlugInElement)
 {
     visitor->trace(m_imageLoader);
-    visitor->trace(m_placeholder);
     visitor->trace(m_persistedPluginWidget);
     HTMLFrameOwnerElement::trace(visitor);
 }
 
 #if ENABLE(OILPAN)
 void HTMLPlugInElement::disconnectContentFrame()
 {
     if (m_persistedPluginWidget) {
         m_persistedPluginWidget->dispose();
         m_persistedPluginWidget = nullptr;
@@ skipping 22 matching lines @@
         LocalFrame* frame = toPluginView(widget)->pluginFrame();
         ASSERT(frame);
         frame->registerPluginElement(this);
     }
 #endif
     m_persistedPluginWidget = widget;
 }
 
 bool HTMLPlugInElement::canProcessDrag() const
 {
-    if (Widget* widget = existingPluginWidget())
-        return widget->isPluginView() && toPluginView(widget)->canProcessDrag();
-    return false;
+    return pluginWidget() && pluginWidget()->isPluginView() && toPluginView(pluginWidget())->canProcessDrag();
 }
 
 bool HTMLPlugInElement::willRespondToMouseClickEvents()
 {
     if (isDisabledFormControl())
         return false;
     LayoutObject* r = layoutObject();
     return r && (r->isEmbeddedObject() || r->isLayoutPart());
 }
 
@@ skipping 117 matching lines @@
     // a LayoutEmbeddedObject or LayoutPart.
     if (useFallbackContent())
         return LayoutObject::createObject(this, style);
 
     if (isImageType()) {
         LayoutImage* image = new LayoutImage(this);
         image->setImageResource(LayoutImageResource::create());
         return image;
     }
 
-    if (usePlaceholderContent())
-        return new LayoutBlockFlow(this);
 
     return new LayoutEmbeddedObject(this);
 }
 
 void HTMLPlugInElement::finishParsingChildren()
 {
     HTMLFrameOwnerElement::finishParsingChildren();
     if (useFallbackContent())
         return;
 
@@ skipping 15 matching lines @@
 
     // 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) {
         Widget* plugin;
 
         if (m_persistedPluginWidget)
             plugin = m_persistedPluginWidget.get();
         else
-            plugin = pluginWidgetForJSBindings();
+            plugin = pluginWidget();
 
         if (plugin)
             m_pluginWrapper = frame->script().createPluginWrapper(plugin);
     }
     return m_pluginWrapper.get();
 }
 
-Widget* HTMLPlugInElement::existingPluginWidget() const
-{
-    if (LayoutPart* layoutPart = existingLayoutPart())
-        return layoutPart->widget();
-    return nullptr;
-}
-
-Widget* HTMLPlugInElement::pluginWidgetForJSBindings()
+Widget* HTMLPlugInElement::pluginWidget() const
 {
     if (LayoutPart* layoutPart = layoutPartForJSBindings())
         return layoutPart->widget();
     return nullptr;
 }
 
 bool HTMLPlugInElement::isPresentationAttribute(const QualifiedName& name) const
 {
     if (name == widthAttr || name == heightAttr || name == vspaceAttr || name == hspaceAttr || name == alignAttr)
         return true;
@@ skipping 51 matching lines @@
 {
     // Needs to load the plugin immediatedly because this function is called
     // when JavaScript code accesses the plugin.
     // FIXME: Check if dispatching events here is safe.
     document().updateLayoutIgnorePendingStylesheets(Document::RunPostLayoutTasksSynchronously);
     return existingLayoutPart();
 }
 
 bool HTMLPlugInElement::isKeyboardFocusable() const
 {
-    if (useFallbackContent() || usePlaceholderContent())
-        return HTMLElement::isKeyboardFocusable();
-
     if (!document().isActive())
         return false;
-
-    if (Widget* widget = existingPluginWidget())
-        return widget->isPluginView() && toPluginView(widget)->supportsKeyboardFocus();
-
-    return false;
+    return pluginWidget() && pluginWidget()->isPluginView() && toPluginView(pluginWidget())->supportsKeyboardFocus();
 }
 
 bool HTMLPlugInElement::hasCustomFocusLogic() const
 {
-    return !useFallbackContent() && !usePlaceholderContent();
+    return !useFallbackContent();
 }
 
 bool HTMLPlugInElement::isPluginElement() const
 {
     return true;
 }
 
 bool HTMLPlugInElement::layoutObjectIsFocusable() const
 {
     if (HTMLFrameOwnerElement::supportsFocus() && HTMLFrameOwnerElement::layoutObjectIsFocusable())
         return true;
 
     if (useFallbackContent() || !layoutObject() || !layoutObject()->isEmbeddedObject())
         return false;
     return !toLayoutEmbeddedObject(layoutObject())->showsUnavailablePluginIndicator();
 }
 
 NPObject* HTMLPlugInElement::getNPObject()
 {
     ASSERT(document().frame());
     if (!m_NPObject)
         m_NPObject = document().frame()->script().createScriptObjectForPluginElement(this);
     return m_NPObject;
 }
 
 void HTMLPlugInElement::setPluginFocus(bool focused)
 {
-    Widget* focusedWidget = existingPluginWidget();
     // NPAPI flash requires to receive messages when web contents focus changes.
-    if (getNPObject() && focusedWidget)
-        focusedWidget->setFocus(focused, WebFocusTypeNone);
+    if (getNPObject() && pluginWidget() && pluginWidget()->isPluginView())

[tommycli, 2015/08/25 00:18:10]

Extra scrutiny here:

This was added by this patch:
https://chromium.googlesource.com/chromium/blink/+/18dff13362438e5c0629d9e4f0...

If we mess it up Flash can be used as a global keylogger.

[jbroman, 2015/08/25 00:34:10]

Do we even still support NPAPI Flash? I'd suspect getNPObject() is always null
in Chrome today. Right? I'd add the author of that patch as a reviewer to be
sure there isn't anything more subtle here, though.

+        toPluginView(pluginWidget())->setFocus(focused, WebFocusTypeNone);
 }
 
 bool HTMLPlugInElement::isImageType()
 {
     if (m_serviceType.isEmpty() && protocolIs(m_url, "data"))
         m_serviceType = mimeTypeFromDataURL(m_url);
 
     if (LocalFrame* frame = document().frame()) {
         KURL completedURL = document().completeURL(m_url);
         return frame->loader().client()->objectContentType(completedURL, m_serviceType, shouldPreferPlugInsForImages()) == ObjectContentImage;
@@ skipping 65 matching lines @@
 
     LayoutEmbeddedObject* layoutObject = layoutEmbeddedObject();
     // FIXME: This code should not depend on layoutObject!
     if ((!layoutObject && requireLayoutObject) || useFallback)
         return false;
 
     WTF_LOG(Plugins, "%p Plugin URL: %s", this, m_url.utf8().data());
     WTF_LOG(Plugins, "   Loaded URL: %s", url.string().utf8().data());
     m_loadedUrl = url;
 
-    OwnPtrWillBeRawPtr<PluginPlaceholder> placeholder = nullptr;
     RefPtrWillBeRawPtr<Widget> widget = m_persistedPluginWidget;
     if (!widget) {
         bool loadManually = document().isPluginDocument() && !document().containsPlugins();
-        placeholder = frame->loader().client()->createPluginPlaceholder(document(), url, paramNames, paramValues, mimeType, loadManually);
-        if (!placeholder) {
-            FrameLoaderClient::DetachedPluginPolicy policy = requireLayoutObject ? FrameLoaderClient::FailOnDetachedPlugin : FrameLoaderClient::AllowDetachedPlugin;
-            widget = frame->loader().client()->createPlugin(this, url, paramNames, paramValues, mimeType, loadManually, policy);
-        }
+        FrameLoaderClient::DetachedPluginPolicy policy = requireLayoutObject ? FrameLoaderClient::FailOnDetachedPlugin : FrameLoaderClient::AllowDetachedPlugin;
+        widget = frame->loader().client()->createPlugin(this, url, paramNames, paramValues, mimeType, loadManually, policy);
     }
 
-    if (!placeholder && !widget) {
+    if (!widget) {
         if (layoutObject && !layoutObject->showsUnavailablePluginIndicator())
             layoutObject->setPluginUnavailabilityReason(LayoutEmbeddedObject::PluginMissing);
-        setPlaceholder(nullptr);
         return false;
     }
 
-    if (placeholder) {
-        setPlaceholder(placeholder.release());
-        return true;
-    }
-
     if (layoutObject) {
         setWidget(widget);
         setPersistedPluginWidget(nullptr);
     } else {
         setPersistedPluginWidget(widget.get());
     }
-    setPlaceholder(nullptr);
     document().setContainsPlugins();
     // TODO(esprehn): WebPluginContainerImpl::setWebLayer also schedules a compositing update, do we need both?
     setNeedsCompositingUpdate();
     // Make sure any input event handlers introduced by the plugin are taken into account.
     if (Page* page = document().frame()->page()) {
         if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator())
             scrollingCoordinator->notifyLayoutUpdated();
     }
     return true;
 }
 
 bool HTMLPlugInElement::shouldUsePlugin(const KURL& url, const String& mimeType, bool hasFallback, bool& useFallback)
 {
     // Allow other plugins to win over QuickTime because if the user has
     // installed a plugin 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();
         String pluginName = pluginData ? pluginData->pluginNameForMimeType(mimeType) : String();
         if (!pluginName.isEmpty() && !pluginName.contains("QuickTime", TextCaseInsensitive))
             return true;
     }
 
     ObjectContentType objectType = document().frame()->loader().client()->objectContentType(url, mimeType, shouldPreferPlugInsForImages());
     // If an object's content can't be handled and it has no fallback, let
     // it be handled as a plugin to show the broken plugin icon.
     useFallback = objectType == ObjectContentNone && hasFallback;
     return objectType == ObjectContentNone || objectType == ObjectContentNetscapePlugin || objectType == ObjectContentOtherPlugin;
-}
 
-void HTMLPlugInElement::setPlaceholder(PassOwnPtrWillBeRawPtr<PluginPlaceholder> placeholder)
-{
-    bool needsLazyReattach = (!placeholder) != (!m_placeholder);
-    if (placeholder) {
-        placeholder->loadIntoContainer(ensureUserAgentShadowRoot());
-        m_placeholder = placeholder;
-    } else {
-        ShadowRoot& shadowRoot = ensureUserAgentShadowRoot();
-        shadowRoot.removeChildren();
-        shadowRoot.appendChild(HTMLContentElement::create(document()));
-        m_placeholder.clear();
-    }
-    if (needsLazyReattach)
-        lazyReattachIfAttached();
 }
 
 void HTMLPlugInElement::dispatchErrorEvent()
 {
     if (document().isPluginDocument() && document().ownerElement())
         document().ownerElement()->dispatchEvent(Event::create(EventTypeNames::error));
     else
         dispatchEvent(Event::create(EventTypeNames::error));
 }
 
@@ skipping 45 matching lines @@
     return false;
 }
 
 bool HTMLPlugInElement::useFallbackContent() const
 {
     return openShadowRoot();
 }
 
 void HTMLPlugInElement::lazyReattachIfNeeded()
 {
-    if (!useFallbackContent() && !usePlaceholderContent() && needsWidgetUpdate() && layoutObject() && !isImageType())
+    if (!useFallbackContent() && needsWidgetUpdate() && layoutObject() && !isImageType())
         lazyReattachIfAttached();
 }
 
 }