BrowserPlugin/WebView - Move plugin lifetime to DOM

Source/core/rendering/RenderWidget.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2006, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. 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
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "config.h"
 #include "core/rendering/RenderWidget.h"
 
 #include "core/accessibility/AXObjectCache.h"
 #include "core/frame/Frame.h"
+#include "core/html/HTMLPlugInElement.h"
 #include "core/platform/graphics/GraphicsContext.h"
 #include "core/rendering/CompositedLayerMapping.h"
 #include "core/rendering/GraphicsContextAnnotator.h"
 #include "core/rendering/HitTestResult.h"
 #include "core/rendering/LayoutRectRecorder.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderView.h"
 #include "wtf/HashMap.h"
 
 using namespace std;
@@ skipping 81 matching lines @@
     clearNode();
     deref();
 }
 
 RenderWidget::~RenderWidget()
 {
     ASSERT(m_refCount <= 0);
     clearWidget();
 }
 
+Widget* RenderWidget::widget() const
+{
+    if (m_widget.get())

[eseidel, 2013/11/18 22:09:54]

Can we just remove RenderWidget's m_widget pointer?  You can't have anonymous
renderers with plugins to my knowledge, so can't we just remove this check?

[wjmaclean, 2013/11/25 17:51:56]

I've taken a stab at this .. please take a look and let me know if anything
looks overly naive.

Done.

+        return m_widget.get();
+
+    // Plugin widgets are now stored in their DOM node, so check there next.
+    Element* element = toElement(node());
+    if (element && element->isPluginElement())
+        return toHTMLPlugInElement(element)->plugin().get();
+
+    return 0;
+}
+
 // Widgets are always placed on integer boundaries, so rounding the size is actually
 // the desired behavior. This function is here because it's otherwise seldom what we
 // want to do with a LayoutRect.
 static inline IntRect roundedIntRect(const LayoutRect& rect)
 {
     return IntRect(roundedIntPoint(rect.location()), roundedIntSize(rect.size()));
 }
 
 bool RenderWidget::setWidgetGeometry(const LayoutRect& frame)
 {
     if (!node())
         return false;
 
+    Widget* widget = this->widget();
+    ASSERT(widget);
+
     IntRect clipRect = roundedIntRect(enclosingLayer()->childrenClipRect());
     IntRect newFrame = roundedIntRect(frame);
     bool clipChanged = m_clipRect != clipRect;
-    bool frameRectChanged = m_widget->frameRect() != newFrame;
+    bool frameRectChanged = widget->frameRect() != newFrame;
 
     if (!frameRectChanged && !clipChanged)
         return false;
 
     m_clipRect = clipRect;
 
     RefPtr<RenderWidget> protector(this);
     RefPtr<Node> protectedNode(node());
-    m_widget->setFrameRect(newFrame);
+    widget->setFrameRect(newFrame);
 
     if (clipChanged && !frameRectChanged)
-        m_widget->clipRectChanged();
+        widget->clipRectChanged();
 
     if (hasLayer() && layer()->compositingState() == PaintsIntoOwnBacking)
         layer()->compositedLayerMapping()->updateAfterWidgetResize();
 
-    bool boundsChanged = m_widget->frameRect().size() != newFrame.size();
+    bool boundsChanged = widget->frameRect().size() != newFrame.size();
     return boundsChanged;
 }
 
 bool RenderWidget::updateWidgetGeometry()
 {
+    Widget* widget = this->widget();
+
     LayoutRect contentBox = contentBoxRect();
     LayoutRect absoluteContentBox(localToAbsoluteQuad(FloatQuad(contentBox)).boundingBox());
-    if (m_widget->isFrameView()) {
+    if (widget->isFrameView()) {
         contentBox.setLocation(absoluteContentBox.location());
         return setWidgetGeometry(contentBox);
     }
 
     return setWidgetGeometry(absoluteContentBox);
 }
 
+// FIXME: Once Frame/FrameElementBase/FrameOwnerElement and HTMLAppletElement

[eseidel, 2013/11/18 22:26:45]

I see.  The problem is there are multiple DOM classes which know how to have a
Widget?  Seems we should just move them all over before adding the browser bits.

I understand you're here for the browser bits.  I'm just not comfortable with
the complexity this change adds to the core code.  We should fix the core code
to make your usecase the easy case first, imo.

[wjmaclean, 2013/11/25 17:51:56]

As per comment regarding removing widget pointer.

Done.

+// can be updated to own their own widgets, this function can be retired in
+// favour of configureWidget().
 void RenderWidget::setWidget(PassRefPtr<Widget> widget)
 {
     if (widget == m_widget)
         return;
 
     if (m_widget) {
         moveWidgetToParentSoon(m_widget.get(), 0);
         clearWidget();
     }
     m_widget = widget;
@@ skipping 12 matching lines @@
                 repaint();
             }
         }
         moveWidgetToParentSoon(m_widget.get(), m_frameView);
     }
 
     if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->childrenChanged(this);
 }
 
+void RenderWidget::configureWidget(ConfigureType type)
+{
+    Widget* widget = this->widget();
+    ASSERT(widget);
+
+    if (type == ConfigureOnDetach) {
+        moveWidgetToParentSoon(widget, 0);
+        return;
+    }
+
+    // type == ConfigureOnAttach.

[eseidel, 2013/11/18 22:26:45]

confused.  Which one of these is the old path vs. the new path?

[wjmaclean, 2013/11/25 17:51:56]

It's not so much an old vs. new distinction as attach/detach. I've restructured
this code in the new patch in a way that will hopefully clarify this.

+    if (widget) {
+        if (style()) {
+            if (!needsLayout())
+                updateWidgetGeometry();
+
+            if (style()->visibility() != VISIBLE) {
+                widget->hide();
+            } else {
+                widget->show();
+                repaint();
+            }
+            if (!widget->parent())
+                moveWidgetToParentSoon(widget, m_frameView);
+        }
+        if (AXObjectCache* cache = document().existingAXObjectCache())
+            cache->childrenChanged(this);
+    }
+}
+
 void RenderWidget::layout()
 {
     ASSERT(needsLayout());
 
     LayoutRectRecorder recorder(*this);
     clearNeedsLayout();
 }
 
 void RenderWidget::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 {
     RenderReplaced::styleDidChange(diff, oldStyle);
-    if (m_widget) {
+    Widget* widget = this->widget();
+
+    if (widget) {
         if (style()->visibility() != VISIBLE)
-            m_widget->hide();
+            widget->hide();
         else
-            m_widget->show();
+            widget->show();
     }
 }
 
 void RenderWidget::paintContents(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     LayoutPoint adjustedPaintOffset = paintOffset + location();
 
+    Widget* widget = this->widget();
+    ASSERT(widget);
+
     // Tell the widget to paint now. This is the only time the widget is allowed
     // to paint itself. That way it will composite properly with z-indexed layers.
-    IntPoint widgetLocation = m_widget->frameRect().location();
+    IntPoint widgetLocation = widget->frameRect().location();
     IntPoint paintLocation(roundToInt(adjustedPaintOffset.x() + borderLeft() + paddingLeft()),
         roundToInt(adjustedPaintOffset.y() + borderTop() + paddingTop()));
     IntRect paintRect = paintInfo.rect;
 
     IntSize widgetPaintOffset = paintLocation - widgetLocation;
     // When painting widgets into compositing layers, tx and ty are relative to the enclosing compositing layer,
     // not the root. In this case, shift the CTM and adjust the paintRect to be root-relative to fix plug-in drawing.
     if (!widgetPaintOffset.isZero()) {
         paintInfo.context->translate(widgetPaintOffset);
         paintRect.move(-widgetPaintOffset);
     }
-    m_widget->paint(paintInfo.context, paintRect);
+    widget->paint(paintInfo.context, paintRect);
 
     if (!widgetPaintOffset.isZero())
         paintInfo.context->translate(-widgetPaintOffset);
 
-    if (m_widget->isFrameView()) {
-        FrameView* frameView = toFrameView(m_widget.get());
+    if (widget->isFrameView()) {
+        FrameView* frameView = toFrameView(widget);
         bool runOverlapTests = !frameView->useSlowRepaintsIfNotOverlapped() || frameView->hasCompositedContent();
         if (paintInfo.overlapTestRequests && runOverlapTests) {
             ASSERT(!paintInfo.overlapTestRequests->contains(this));
-            paintInfo.overlapTestRequests->set(this, m_widget->frameRect());
+            paintInfo.overlapTestRequests->set(this, widget->frameRect());
         }
     }
 }
 
 void RenderWidget::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     ANNOTATE_GRAPHICS_CONTEXT(paintInfo, this);
 
     if (!shouldPaint(paintInfo, paintOffset))
         return;
@@ skipping 20 matching lines @@
         if (borderRect.isEmpty())
             return;
 
         // Push a clip if we have a border radius, since we want to round the foreground content that gets painted.
         paintInfo.context->save();
         RoundedRect roundedInnerRect = style()->getRoundedInnerBorderFor(borderRect,
             paddingTop() + borderTop(), paddingBottom() + borderBottom(), paddingLeft() + borderLeft(), paddingRight() + borderRight(), true, true);
         clipRoundedInnerRect(paintInfo.context, borderRect, roundedInnerRect);
     }
 
-    if (m_widget)
+    Widget* widget = this->widget();
+    if (widget)
         paintContents(paintInfo, paintOffset);
 
     if (style()->hasBorderRadius())
         paintInfo.context->restore();
 
     // Paint a partially transparent wash over selected widgets.
     if (isSelected() && !document().printing()) {
         // FIXME: selectionRect() is in absolute, not painting coordinates.
         paintInfo.context->fillRect(pixelSnappedIntRect(selectionRect()), selectionBackgroundColor());
     }
 
     if (canResize())
         layer()->scrollableArea()->paintResizer(paintInfo.context, roundedIntPoint(adjustedPaintOffset), paintInfo.rect);
 }
 
 void RenderWidget::setIsOverlapped(bool isOverlapped)
 {
-    ASSERT(m_widget);
-    ASSERT(m_widget->isFrameView());
-    toFrameView(m_widget.get())->setIsOverlapped(isOverlapped);
+    Widget* widget = this->widget();
+    ASSERT(widget);
+    ASSERT(widget->isFrameView());
+    toFrameView(widget)->setIsOverlapped(isOverlapped);
 }
 
 void RenderWidget::deref()
 {
     if (--m_refCount <= 0)
         postDestroy();
 }
 
 void RenderWidget::updateWidgetPosition()
 {
-    if (!m_widget || !node()) // Check the node in case destroy() has been called.
+    Widget* widget = this->widget();
+    if (!widget || !node()) // Check the node in case destroy() has been called.
         return;
 
     bool boundsChanged = updateWidgetGeometry();
 
     // if the frame bounds got changed, or if view needs layout (possibly indicating
     // content size is wrong) we have to do a layout to set the right widget size
-    if (m_widget && m_widget->isFrameView()) {
-        FrameView* frameView = toFrameView(m_widget.get());
+    if (widget && widget->isFrameView()) {
+        FrameView* frameView = toFrameView(widget);
         // Check the frame's page to make sure that the frame isn't in the process of being destroyed.
         if ((boundsChanged || frameView->needsLayout()) && frameView->frame().page())
             frameView->layout();
     }
 }
 
 void RenderWidget::widgetPositionsUpdated()
 {
-    if (!m_widget)
+    Widget* widget = this->widget();
+    if (!widget)
         return;
-    m_widget->widgetPositionsUpdated();
+    widget->widgetPositionsUpdated();
 }
 
 IntRect RenderWidget::windowClipRect() const
 {
     if (!m_frameView)
         return IntRect();
 
     return intersection(m_frameView->contentsToWindow(m_clipRect), m_frameView->windowClipRect());
 }
 
@@ skipping 16 matching lines @@
 CursorDirective RenderWidget::getCursor(const LayoutPoint& point, Cursor& cursor) const
 {
     if (widget() && widget()->isPluginView()) {
         // A plug-in is responsible for setting the cursor when the pointer is over it.
         return DoNotSetCursor;
     }
     return RenderReplaced::getCursor(point, cursor);
 }
 
 } // namespace WebCore