Move plugins to be stored in HTMLPlugInElement.

third_party/WebKit/Source/core/layout/LayoutPart.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Simon Hausmann <hausmann@kde.org>
  *           (C) 2000 Stefan Schimanski (1Stein@gmx.de)
  * Copyright (C) 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
  *
  * 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
@@ skipping 10 matching lines @@
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "core/layout/LayoutPart.h"
 
 #include "core/dom/AXObjectCache.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLFrameElementBase.h"
+#include "core/html/HTMLPlugInElement.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutAnalyzer.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/api/LayoutAPIShim.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/paint/PartPainter.h"
 #include "core/plugins/PluginView.h"
 
 namespace blink {
 
@@ skipping 50 matching lines @@
 FrameViewBase* LayoutPart::frameViewBase() const {
   // Plugin FrameViewBases are stored in their DOM node.
   Element* element = toElement(node());
 
   if (element && element->isFrameOwnerElement())
     return toHTMLFrameOwnerElement(element)->ownedWidget();
 
   return nullptr;
 }
 
+PluginView* LayoutPart::plugin() const {
+  // Plugins are stored in their DOM node.
+  return node() && isHTMLPlugInElement(node())
+             ? toHTMLPlugInElement(node())->plugin()
+             : nullptr;
+}
+
 PaintLayerType LayoutPart::layerTypeRequired() const {
   PaintLayerType type = LayoutReplaced::layerTypeRequired();
   if (type != NoPaintLayer)
     return type;
   return ForcedPaintLayer;
 }
 
 bool LayoutPart::requiresAcceleratedCompositing() const {
   // There are two general cases in which we can return true. First, if this is
   // a plugin LayoutObject and the plugin has a layer, then we need a layer.
   // Second, if this is a LayoutObject with a contentDocument and that document
   // needs a layer, then we need a layer.
-  if (frameViewBase() && frameViewBase()->isPluginView() &&
-      toPluginView(frameViewBase())->platformLayer())
+  PluginView* pluginView = plugin();
+  if (pluginView && pluginView->platformLayer())
     return true;
 
   if (!node() || !node()->isFrameOwnerElement())
     return false;
 
   HTMLFrameOwnerElement* element = toHTMLFrameOwnerElement(node());
   if (element->contentFrame() && element->contentFrame()->isRemoteFrame())
     return true;
 
   if (Document* contentDocument = element->contentDocument()) {
@@ skipping 115 matching lines @@
   LayoutReplaced::styleDidChange(diff, oldStyle);
   FrameViewBase* frameViewBase = this->frameViewBase();
 
   if (!frameViewBase)
     return;
 
   // If the iframe has custom scrollbars, recalculate their style.
   if (frameViewBase && frameViewBase->isFrameView())
     toFrameView(frameViewBase)->recalculateCustomScrollbarStyle();
 
+  // TODO(joelhockey): Does this need separate code for plugins?

[haraken, 2017/03/22 15:32:33]

I guess yes.

Can you add CHECK(!(node() && isHTMLPlugInElement(node()))) and check if your
guess is correct? The same comment for other TODOs in this CL.

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

Thanks, that is a helpful approach.  It showed that plugins do indeed get called
from here.  For now, I am setting FrameViewBase to PluginView if not null, else
FrameView.

Once I remove FrameViewBase, my plan is to have separate version of
updateOnWidgetChange and updateGeometry:
- updateOnFrameChange
- updateFrameGeometry
- updateOnPluginChange
- updatePluginGeometry.

It is clear to see where each of these are called separately.

   if (style()->visibility() != EVisibility::kVisible) {
     frameViewBase->hide();

[haraken, 2017/03/22 15:32:33]

One way to handle both the FrameViewBase case and the plugin case would be to
implement the show/hide method on node() (i.e., HTMLFrameOwnerElement and
HTMLPluginElement). Then HTMLFrameOwnerElement and HTMLPluginElement can
dispatch those methods to proper things (i.e., m_frameViewBase or m_plugin).

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

This function will be ok to take FrameViewBase as input and use polymorphism to
call on either Frame or Plugin.  I will create a common ABC with hide/show
methods.

[haraken, 2017/03/28 07:39:41]

However, you're planning to remove the inheritance between FrameViewBase and
Plugin, right? At that point, you can no longer rely on the polymorphism.

[joelhockey, 2017/03/28 22:56:23]

Yes, I will remove the inheritance from FrameView -> FrameViewBase and
PluginView -> FrameViewBase.  One of my current thoughts is to create a new
common abstract base class named Focusable which has functions hide and show. 
FrameView and PluginView will both extend this.  LayoutPart can then have a
single way to get a handle on Focusable and use polymorphism to call hide/show
on either Frame or Plugin.  I do also like your suggestion to defer this method
into Node and then have HTMLPlugInElement and HTMLFrameOwnerElement provide
override implementations.  I might try them both and see what I think looks the
best design.

There are also some other geometry methods that are common to both classes.  I'm
reluctant to put even more methods on Node, although maybe a few more can't hurt
when its already got so many :-)

[haraken, 2017/03/29 11:04:46]

Sounds like a nice plan.

   } else {
     frameViewBase->show();
   }
 }
 
 void LayoutPart::layout() {
   ASSERT(needsLayout());
   LayoutAnalyzer::Scope analyzer(*this);
   clearNeedsLayout();
 }
 
 void LayoutPart::paint(const PaintInfo& paintInfo,
                        const LayoutPoint& paintOffset) const {
   PartPainter(*this).paint(paintInfo, paintOffset);
 }
 
 void LayoutPart::paintContents(const PaintInfo& paintInfo,
                                const LayoutPoint& paintOffset) const {
   PartPainter(*this).paintContents(paintInfo, paintOffset);
 }
 
 CursorDirective LayoutPart::getCursor(const LayoutPoint& point,
                                       Cursor& cursor) const {
-  if (frameViewBase() && frameViewBase()->isPluginView()) {
+  if (plugin()) {
     // A plugin is responsible for setting the cursor when the pointer is over
     // it.
     return DoNotSetCursor;
   }
   return LayoutReplaced::getCursor(point, cursor);
 }
 
 LayoutRect LayoutPart::replacedContentRect() const {
   // We don't propagate sub-pixel into sub-frame layout, in other words, the
   // rect is snapped at the document boundary, and sub-pixel movement could
   // cause the sub-frame to layout due to the 1px snap difference. In order to
   // avoid that, the size of sub-frame is rounded in advance.
   LayoutRect sizeRoundedRect = contentBoxRect();
   sizeRoundedRect.setSize(LayoutSize(roundedIntSize(sizeRoundedRect.size())));
   return sizeRoundedRect;
 }
 
 void LayoutPart::updateOnWidgetChange() {
   FrameViewBase* frameViewBase = this->frameViewBase();
   if (!frameViewBase)
     return;
 
   if (!style())
     return;
 
   if (!needsLayout())
     updateGeometryInternal();
 
+  // TODO(joelhockey): Does this need special handling for plugin?

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

I think this also needs to be handled: the main subclass of PluginView is
WebPluginContainerImpl, which forwards the visibility change to the plugin
itself. =/

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

Thanks.  I just noticed how the impl forwards the change through to itself. 
Well worthy of a wry smily =/.  As per comment above, for now I will get either
PluginView or FrameView here, but my longer plan is to duplicate
updateOnWidgetChange to have separate versions for Frame and Plugin.

   if (style()->visibility() != EVisibility::kVisible) {
     frameViewBase->hide();
   } else {
     frameViewBase->show();
     // FIXME: Why do we issue a full paint invalidation in this case, but not
     // the other?
     setShouldDoFullPaintInvalidation();
   }
 }
 
 void LayoutPart::updateGeometry() {
   FrameViewBase* frameViewBase = this->frameViewBase();
   if (!frameViewBase ||
       !node())  // Check the node in case destroy() has been called.
     return;
 
   LayoutRect newFrame = replacedContentRect();
   DCHECK(newFrame.size() == roundedIntSize(newFrame.size()));
+  // TODO(joelhockey): Does this need special handling for plugin?
   bool boundsWillChange =
       LayoutSize(frameViewBase->frameRect().size()) != newFrame.size();
 
   FrameView* frameView =
       frameViewBase->isFrameView() ? toFrameView(frameViewBase) : nullptr;
 
   // If frame bounds are changing mark the view for layout. Also check the
   // frame's page to make sure that the frame isn't in the process of being
   // destroyed. If iframe scrollbars needs reconstruction from native to custom
   // scrollbar, then also we need to layout the frameview.
@@ skipping 33 matching lines @@
   // FrameView::updateViewportIntersectionIfNeeded()
   // RemoteFrameView::frameRectsChanged().
   // WebPluginContainerImpl::reportGeometry()
   // TODO(trchen): Remove this hack once we fixed all callers.
   FloatRect absoluteBoundingBox =
       localToAbsoluteQuad(FloatRect(replacedContentRect())).boundingBox();
   frameRect.setLocation(roundedIntPoint(absoluteBoundingBox.location()));
 
   // Why is the protector needed?
   RefPtr<LayoutPart> protector(this);
+  // TODO(joelhockey): Does this need special handling for plugin?
   frameViewBase->setFrameRect(frameRect);
 }
 
 void LayoutPart::invalidatePaintOfSubtreesIfNeeded(
     const PaintInvalidationState& paintInvalidationState) {
   if (frameViewBase() && frameViewBase()->isFrameView() &&
       !isThrottledFrameView()) {
     FrameView* childFrameView = toFrameView(frameViewBase());
     // |childFrameView| is in another document, which could be
     // missing its LayoutView. TODO(jchaffraix): Ideally we should
@@ skipping 11 matching lines @@
 }
 
 bool LayoutPart::isThrottledFrameView() const {
   if (!frameViewBase() || !frameViewBase()->isFrameView())
     return false;
   const FrameView* frameView = toFrameView(frameViewBase());
   return frameView->shouldThrottleRendering();
 }
 
 }  // namespace blink