Remove most of Widget (FrameViewBase) class from 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_persistedPluginWidget);
+  visitor->trace(m_persistedPlugin);
   HTMLFrameOwnerElement::trace(visitor);
 }
 
-void HTMLPlugInElement::setPersistedPluginWidget(FrameViewBase* frameViewBase) {
-  if (m_persistedPluginWidget == frameViewBase)
+// 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);
+}
+
+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;
+}
+
+void HTMLPlugInElement::setPersistedPlugin(PluginView* plugin) {
+  if (m_persistedPlugin == plugin)
     return;
-  if (m_persistedPluginWidget) {
-    if (m_persistedPluginWidget->isPluginView()) {
-      m_persistedPluginWidget->hide();
-      disposeWidgetSoon(m_persistedPluginWidget.release());
-    } else {
-      DCHECK(m_persistedPluginWidget->isFrameView() ||
-             m_persistedPluginWidget->isRemoteFrameView());
-    }
+  if (m_persistedPlugin) {
+    m_persistedPlugin->hide();
+    disposeWidgetSoon(m_persistedPlugin.release());
   }
-  m_persistedPluginWidget = frameViewBase;
+  m_persistedPlugin = plugin;
 }
 
 bool HTMLPlugInElement::requestObjectInternal(
     const String& url,
     const String& mimeType,
     const Vector<String>& paramNames,
     const Vector<String>& paramValues) {
   if (url.isEmpty() && mimeType.isEmpty())
     return false;
 
@@ skipping 47 matching lines @@
     m_imageLoader->elementDidMoveToNewDocument();
   HTMLFrameOwnerElement::didMoveToNewDocument(oldDocument);
 }
 
 void HTMLPlugInElement::attachLayoutTree(const AttachContext& context) {
   HTMLFrameOwnerElement::attachLayoutTree(context);
 
   if (!layoutObject() || useFallbackContent()) {
     // If we don't have a layoutObject we have to dispose of any plugins
     // which we persisted over a reattach.
-    if (m_persistedPluginWidget) {
+    if (m_persistedPlugin) {
       HTMLFrameOwnerElement::UpdateSuspendScope suspendWidgetHierarchyUpdates;
-      setPersistedPluginWidget(nullptr);
+      setPersistedPlugin(nullptr);
     }
     return;
   }
 
   if (isImageType()) {
     if (!m_imageLoader)
       m_imageLoader = HTMLImageLoader::create(this);
     m_imageLoader->updateFromElement();
   } else if (needsPluginUpdate() && !layoutEmbeddedItem().isNull() &&
              !layoutEmbeddedItem().showsUnavailablePluginIndicator() &&
              !wouldLoadAsNetscapePlugin(m_url, m_serviceType) &&
              !m_isDelayingLoadEvent) {
     m_isDelayingLoadEvent = true;
     document().incrementLoadEventDelayCount();
     document().loadPluginsSoon();
   }
 }
 
 void HTMLPlugInElement::updatePlugin() {
   updatePluginInternal();
   if (m_isDelayingLoadEvent) {
     m_isDelayingLoadEvent = false;
     document().decrementLoadEventDelayCount();
   }
 }
 
 void HTMLPlugInElement::removedFrom(ContainerNode* insertionPoint) {
   // If we've persisted the plugin and we're removed from the tree then
   // make sure we cleanup the persistance pointer.
-  if (m_persistedPluginWidget) {
+  if (m_persistedPlugin) {
     // TODO(dcheng): This UpdateSuspendScope doesn't seem to provide much;
     // investigate removing it.
     HTMLFrameOwnerElement::UpdateSuspendScope suspendWidgetHierarchyUpdates;
-    setPersistedPluginWidget(nullptr);
+    setPersistedPlugin(nullptr);
   }
   HTMLFrameOwnerElement::removedFrom(insertionPoint);
 }
 
 void HTMLPlugInElement::requestPluginCreationWithoutLayoutObjectIfPossible() {
   if (m_serviceType.isEmpty())
     return;
 
   if (!document().frame() ||
       !document().frame()->loader().client()->canCreatePluginWithoutRenderer(
@@ skipping 19 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 {
-  if (FrameViewBase* frameViewBase = ownedWidget()) {
-    return frameViewBase->isPluginView() &&
-           toPluginView(frameViewBase)->platformLayer();
-  }
-  return false;
+  return ownedPlugin() && ownedPlugin()->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 FrameViewBase we actually own.
-  FrameViewBase* plugin = ownedWidget();
+  // Only try to persist a plugin we actually own.
+  PluginView* plugin = ownedPlugin();
   if (plugin && context.performingReattach) {
-    setPersistedPluginWidget(releaseWidget());
+    setPersistedPlugin(releasePlugin());
   } else {
-    // Clear the FrameViewBase; will trigger disposal of it with Oilpan.
-    setWidget(nullptr);
+    // Clear the plugin; will trigger disposal of it with Oilpan.
+    setPlugin(nullptr);
   }
 
   resetInstance();
 
   HTMLFrameOwnerElement::detachLayoutTree(context);
 }
 
 LayoutObject* HTMLPlugInElement::createLayoutObject(
     const ComputedStyle& style) {
   // Fallback content breaks the DOM->layoutObject class relationship of this
@@ skipping 30 matching lines @@
   LocalFrame* frame = document().frame();
   if (!frame)
     return nullptr;
 
   // 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) {
     FrameViewBase* plugin;
 
-    if (m_persistedPluginWidget)
-      plugin = m_persistedPluginWidget.get();
+    if (m_persistedPlugin)
+      plugin = m_persistedPlugin.get();
     else
       plugin = pluginWidget();
 
     if (plugin)
       m_pluginWrapper = frame->script().createPluginWrapper(plugin);
   }
   return m_pluginWrapper.get();
 }
 
 FrameViewBase* HTMLPlugInElement::pluginWidget() const {
@@ skipping 80 matching lines @@
 bool HTMLPlugInElement::hasCustomFocusLogic() const {
   return !useFallbackContent();
 }
 
 bool HTMLPlugInElement::isPluginElement() const {
   return true;
 }
 
 void HTMLPlugInElement::disconnectContentFrame() {
   HTMLFrameOwnerElement::disconnectContentFrame();
-  setPersistedPluginWidget(nullptr);
+  setPersistedPlugin(nullptr);
 }
 
 bool HTMLPlugInElement::layoutObjectIsFocusable() const {
   if (HTMLFrameOwnerElement::supportsFocus() &&
       HTMLFrameOwnerElement::layoutObjectIsFocusable())
     return true;
 
   if (useFallbackContent() || !HTMLFrameOwnerElement::layoutObjectIsFocusable())
     return false;
   return m_pluginIsAvailable;
@@ skipping 73 matching lines @@
 
   LayoutEmbeddedItem layoutItem = layoutEmbeddedItem();
   // FIXME: This code should not depend on layoutObject!
   if ((layoutItem.isNull() && requireLayoutObject) || useFallback)
     return false;
 
   VLOG(1) << this << " Plugin URL: " << m_url;
   VLOG(1) << "Loaded URL: " << url.getString();
   m_loadedUrl = url;
 
-  if (m_persistedPluginWidget) {
-    setWidget(m_persistedPluginWidget.release());
+  if (m_persistedPlugin) {
+    setPlugin(m_persistedPlugin.release());
   } else {
     bool loadManually =
         document().isPluginDocument() && !document().containsPlugins();
     LocalFrameClient::DetachedPluginPolicy policy =
         requireLayoutObject ? LocalFrameClient::FailOnDetachedPlugin
                             : LocalFrameClient::AllowDetachedPlugin;
-    FrameViewBase* frameViewBase = frame->loader().client()->createPlugin(
+    PluginView* plugin = frame->loader().client()->createPlugin(
         this, url, paramNames, paramValues, mimeType, loadManually, policy);
-    if (!frameViewBase) {
+    if (!plugin) {
       if (!layoutItem.isNull() &&
           !layoutItem.showsUnavailablePluginIndicator()) {
         m_pluginIsAvailable = false;
         layoutItem.setPluginAvailability(LayoutEmbeddedObject::PluginMissing);
       }
       return false;
     }
 
     if (!layoutItem.isNull())
-      setWidget(frameViewBase);
+      setPlugin(plugin);
     else
-      setPersistedPluginWidget(frameViewBase);
+      setPersistedPlugin(plugin);
   }
 
   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 =
@@ skipping 85 matching lines @@
 }
 
 bool HTMLPlugInElement::useFallbackContent() const {
   return false;
 }
 
 void HTMLPlugInElement::lazyReattachIfNeeded() {
   if (!useFallbackContent() && needsPluginUpdate() && layoutObject() &&
       !isImageType()) {
     lazyReattachIfAttached();
-    setPersistedPluginWidget(nullptr);
+    setPersistedPlugin(nullptr);
   }
 }
 
 }  // namespace blink