Move plugins to be stored in HTMLPlugInElement.

third_party/WebKit/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 74 matching lines @@
       m_shouldPreferPlugInsForImages(preferPlugInsForImagesOption ==
                                      ShouldPreferPlugInsForImages) {}
 
 HTMLPlugInElement::~HTMLPlugInElement() {
   DCHECK(!m_pluginWrapper);  // cleared in detachLayoutTree()
   DCHECK(!m_isDelayingLoadEvent);
 }
 
 DEFINE_TRACE(HTMLPlugInElement) {
   visitor->trace(m_imageLoader);
+  visitor->trace(m_plugin);
   visitor->trace(m_persistedPlugin);
   HTMLFrameOwnerElement::trace(visitor);
 }
 
-// TODO(joelhockey): Move implementation of HTMLFrameOwnerElement
-// setWidget/releaseWidget/ownedWidget that relates to plugins to here and
-// remove inheritance from PluginView to FrameViewBase.
-void HTMLPlugInElement::setPlugin(PluginView* pluginView) {
-  setWidget(pluginView);
+void HTMLPlugInElement::setPlugin(PluginView* plugin) {
+  if (plugin == m_plugin)
+    return;
+
+  // Remove and dispose the old plugin if we had one.
+  if (m_plugin) {
+    document().view()->removePlugin(m_plugin);
+    disposeWidgetSoon(m_plugin);
+  }
+  m_plugin = plugin;
+
+  // TODO(joelhockey): I copied the rest of this method from
+  // HTMLFrameOwnerElement.  I don't really know what it does.
+  // Are the layoutPartItem.isNull check and DCHECKs required?
+  LayoutPart* layoutPart = toLayoutPart(layoutObject());
+  LayoutPartItem layoutPartItem = LayoutPartItem(layoutPart);
+  if (layoutPartItem.isNull())
+    return;
+
+  // Update layout and frame with new plugin.
+  if (m_plugin) {
+    layoutPartItem.updateOnWidgetChange();
+
+    DCHECK_EQ(document().view(), layoutPartItem.frameView());
+    DCHECK(layoutPartItem.frameView());
+    document().view()->addPlugin(plugin);
+  }
+
+  // Apparently accessibility objects might have been modified if plugin
+  // was removed.
+  if (AXObjectCache* cache = document().existingAXObjectCache())
+    cache->childrenChanged(layoutPart);
 }
 
 PluginView* HTMLPlugInElement::releasePlugin() {
-  FrameViewBase* plugin = releaseWidget();
-  return plugin && plugin->isPluginView() ? toPluginView(plugin) : nullptr;
-}
-
-PluginView* HTMLPlugInElement::ownedPlugin() const {
-  FrameViewBase* plugin = ownedWidget();
-  return plugin && plugin->isPluginView() ? toPluginView(plugin) : nullptr;
+  if (!m_plugin)
+    return nullptr;
+  document().view()->removePlugin(m_plugin);
+  LayoutPart* layoutPart = toLayoutPart(layoutObject());
+  if (layoutPart) {
+    if (AXObjectCache* cache = document().existingAXObjectCache())
+      cache->childrenChanged(layoutPart);
+  }
+  return m_plugin.release();
 }
 
 void HTMLPlugInElement::setPersistedPlugin(PluginView* plugin) {
   if (m_persistedPlugin == plugin)
     return;
   if (m_persistedPlugin) {
     m_persistedPlugin->hide();
     disposeWidgetSoon(m_persistedPlugin.release());
   }
   m_persistedPlugin = plugin;
@@ skipping 22 matching lines @@
     // new frame and set it as the LayoutPart's FrameViewBase, causing what was
     // previously in the FrameViewBase to be torn down.
     return loadOrRedirectSubframe(completedURL, getNameAttribute(), true);
   }
 
   return loadPlugin(completedURL, mimeType, paramNames, paramValues,
                     useFallback, true);
 }
 
 bool HTMLPlugInElement::canProcessDrag() const {
-  return pluginWidget() && pluginWidget()->isPluginView() &&
-         toPluginView(pluginWidget())->canProcessDrag();
+  return pluginWidget() && pluginWidget()->canProcessDrag();
 }
 
 bool HTMLPlugInElement::canStartSelection() const {
   return useFallbackContent() && Node::canStartSelection();
 }
 
 bool HTMLPlugInElement::willRespondToMouseClickEvents() {
   if (isDisabledFormControl())
     return false;
   LayoutObject* r = layoutObject();
   return r && (r->isEmbeddedObject() || r->isLayoutPart());
 }
 
 void HTMLPlugInElement::removeAllEventListeners() {
   HTMLFrameOwnerElement::removeAllEventListeners();
-  if (LayoutPart* layoutObject = existingLayoutPart()) {
-    if (FrameViewBase* frameViewBase = layoutObject->frameViewBase())
-      frameViewBase->eventListenersRemoved();
+  if (m_plugin) {
+    m_plugin.get()->eventListenersRemoved();

[dcheng, 2017/03/23 07:21:42]

Minor nit: no .get() is needed here

[joelhockey, 2017/03/27 06:42:21]

Thanks.  Do let me know when my code is not idiomatic.  I'm still getting up to
speed on C++.

   }
 }
 
 void HTMLPlugInElement::didMoveToNewDocument(Document& oldDocument) {
   if (m_imageLoader)
     m_imageLoader->elementDidMoveToNewDocument();
   HTMLFrameOwnerElement::didMoveToNewDocument(oldDocument);
 }
 
 void HTMLPlugInElement::attachLayoutTree(const AttachContext& context) {
@@ skipping 71 matching lines @@
   Vector<String> paramValues;
 
   paramNames.push_back("type");
   paramValues.push_back(m_serviceType);
 
   bool useFallback = false;
   loadPlugin(url, m_serviceType, paramNames, paramValues, useFallback, false);
 }
 
 bool HTMLPlugInElement::shouldAccelerate() const {
-  return ownedPlugin() && ownedPlugin()->platformLayer();
+  return m_plugin && m_plugin->platformLayer();
 }
 
 void HTMLPlugInElement::detachLayoutTree(const AttachContext& context) {
   // Update the FrameViewBase the next time we attach (detaching destroys the
   // plugin).
   // FIXME: None of this "needsPluginUpdate" related code looks right.
   if (layoutObject() && !useFallbackContent())
     setNeedsPluginUpdate(true);
 
   if (m_isDelayingLoadEvent) {
     m_isDelayingLoadEvent = false;
     document().decrementLoadEventDelayCount();
   }
 
   // Only try to persist a plugin we actually own.
-  PluginView* plugin = ownedPlugin();
-  if (plugin && context.performingReattach) {
+  if (m_plugin && context.performingReattach) {
     setPersistedPlugin(releasePlugin());
   } else {
     // Clear the plugin; will trigger disposal of it with Oilpan.
     setPlugin(nullptr);
   }
 
   resetInstance();
 
   HTMLFrameOwnerElement::detachLayoutTree(context);
 }
@@ skipping 45 matching lines @@
       plugin = m_persistedPlugin.get();
     else
       plugin = pluginWidget();
 
     if (plugin)
       m_pluginWrapper = frame->script().createPluginWrapper(plugin);
   }
   return m_pluginWrapper.get();
 }
 
-FrameViewBase* HTMLPlugInElement::pluginWidget() const {
+// TODO(joelhockey): Remove this and use m_plugin.
+// I can't see how calling layoutPartForJSBindings can change
+// the previous Widget, or the new m_plugin.
+PluginView* HTMLPlugInElement::pluginWidget() const {
   if (LayoutPart* layoutPart = layoutPartForJSBindings())

[dcheng, 2017/03/23 07:21:42]

This will synchronously trigger initialization of the plugin if script tries to
access it, so it's important to keep =(

[joelhockey, 2017/03/27 06:42:21]

Ack.  In another CL I might see if I can remove this method pluginWidget, and
also layoutPartForJSBindings and put the
document().updateStyleAndLayoutIgnorePendingStylesheets call into pluginWrapper
which looks like the only entry point where JS calls to plugin.

-    return layoutPart->frameViewBase();
+    return layoutPart->plugin();
   return nullptr;
 }
 
+PluginView* HTMLPlugInElement::plugin() const {
+  return m_plugin.get();
+}
+
 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,
@@ skipping 29 matching lines @@
   // code in EventHandler; these code paths should be united.
 
   LayoutObject* r = layoutObject();
   if (!r || !r->isLayoutPart())
     return;
   if (r->isEmbeddedObject()) {
     if (LayoutEmbeddedItem(toLayoutEmbeddedObject(r))
             .showsUnavailablePluginIndicator())
       return;
   }
-  FrameViewBase* frameViewBase = toLayoutPart(r)->frameViewBase();
-  if (!frameViewBase)
+  if (!m_plugin)
     return;
-  frameViewBase->handleEvent(event);
+  m_plugin->handleEvent(event);
   if (event->defaultHandled())
     return;
   HTMLFrameOwnerElement::defaultEventHandler(event);
 }
 
 LayoutPart* HTMLPlugInElement::layoutPartForJSBindings() const {
   // 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().updateStyleAndLayoutIgnorePendingStylesheets(
       Document::RunPostLayoutTasksSynchronously);
   return existingLayoutPart();
 }
 
 bool HTMLPlugInElement::isKeyboardFocusable() const {
   if (HTMLFrameOwnerElement::isKeyboardFocusable())
     return true;
   return document().isActive() && pluginWidget() &&
-         pluginWidget()->isPluginView() &&
-         toPluginView(pluginWidget())->supportsKeyboardFocus();
+         pluginWidget()->supportsKeyboardFocus();
 }
 
 bool HTMLPlugInElement::hasCustomFocusLogic() const {
   return !useFallbackContent();
 }
 
 bool HTMLPlugInElement::isPluginElement() const {
   return true;
 }
 
@@ skipping 219 matching lines @@
 
 void HTMLPlugInElement::lazyReattachIfNeeded() {
   if (!useFallbackContent() && needsPluginUpdate() && layoutObject() &&
       !isImageType()) {
     lazyReattachIfAttached();
     setPersistedPlugin(nullptr);
   }
 }
 
 }  // namespace blink