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.  There may be parts that can be removed
+  // such as the layoutPartItem.isNull check and DCHECKs.

[dcheng, 2017/04/04 07:20:12]

I feel a bit uneasy about this code duplication. If it mostly ends up looking
similar, can we consider merging them back together?

(I think one of the reasons I'm not entirely comfortable with this change is one
of our goals is get rid of widget trees, and in some ways, we're actually
creating a parallel tree of plugins atm. But maybe that's OK because we're going
to get rid of the original widget tree (m_children) eventually?)

[joelhockey, 2017/04/04 23:39:05]

My primary focus has bene to remove the common base class
(Widget/FrameViewBase).  The primary difference between this method and
HTMLFrameOwnerElement::setWidget is using m_plugins rather than m_children.  So
I agree that I have created something parallel, but technically it is not a
tree.  It is a set of plugins that belong to a frame.  Once I have removed
FrameView::m_children, hopefully a lot of the duplication can go away.  But I
couldn't say right now exactly how it will all turn out.

Again, I don't mind to abandon this CL and maybe I should focus first to remove
m_children.  However everything is all quite tangled and I think it is easier to
remove m_children if I can first pull plugin and scrollbar out.

+  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->eventListenersRemoved();
   }
 }
 
 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.
+// Maybe just pluginWrapper function should check if m_plugin is null,
+// and call document().updateStyleAndLayoutIgnorePendingStylesheets as per
+// layoutPartForJSBindings.
+PluginView* HTMLPlugInElement::pluginWidget() const {
   if (LayoutPart* layoutPart = layoutPartForJSBindings())
-    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