Replace RenderFullScreen with top layer

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 50 matching lines @@
     , m_NPObject(0)
     , m_isCapturingMouseEvents(false)
     , m_inBeforeLoadEventHandler(false)
     // m_needsWidgetUpdate(!createdByParser) allows HTMLObjectElement to delay
     // widget updates until after all children are parsed. For HTMLEmbedElement
     // this delay is unnecessary, but it is simpler to make both classes share
     // the same codepath in this class.
     , m_needsWidgetUpdate(!createdByParser)
     , m_shouldPreferPlugInsForImages(preferPlugInsForImagesOption == ShouldPreferPlugInsForImages)
     , m_displayState(Playing)
+    , m_protectWidgetDuringReattach(0)
 {
     setHasCustomStyleCallbacks();
 }
 
 HTMLPlugInElement::~HTMLPlugInElement()
 {
     ASSERT(!m_pluginWrapper); // cleared in detach()
     ASSERT(!m_isDelayingLoadEvent);
 
     if (m_NPObject) {
@@ skipping 28 matching lines @@
 {
     if (m_imageLoader)
         m_imageLoader->elementDidMoveToNewDocument();
     HTMLFrameOwnerElement::didMoveToNewDocument(oldDocument);
 }
 
 void HTMLPlugInElement::attach(const AttachContext& context)
 {
     HTMLFrameOwnerElement::attach(context);
 
+    if (m_protectWidgetDuringReattach) {
+        RenderEmbeddedObject* object = renderEmbeddedObject();
+        if (object && !needsWidgetUpdate()) {
+            object->setWidget(m_protectWidgetDuringReattach.get());
+            m_protectWidgetDuringReattach.clear();
+            return;
+        }
+        m_protectWidgetDuringReattach.clear();
+    }
+
     if (!renderer() || useFallbackContent())
         return;
+
     if (isImageType()) {
         if (!m_imageLoader)
             m_imageLoader = adoptPtr(new HTMLImageLoader(this));
         m_imageLoader->updateFromElement();
     } else if (needsWidgetUpdate()
         && renderEmbeddedObject()
         && !renderEmbeddedObject()->showsUnavailablePluginIndicator()
         && !wouldLoadAsNetscapePlugin(m_url, m_serviceType)
         && !m_isDelayingLoadEvent) {
         m_isDelayingLoadEvent = true;
         document().incrementLoadEventDelayCount();
     }
 }
 
 void HTMLPlugInElement::updateWidget()
 {
     RefPtr<HTMLPlugInElement> protector(this);
     updateWidgetInternal();
     if (m_isDelayingLoadEvent) {
         m_isDelayingLoadEvent = false;
         document().decrementLoadEventDelayCount();
     }
 }
 
 void HTMLPlugInElement::detach(const AttachContext& context)
 {
     // Update the widget the next time we attach (detaching destroys the plugin).
     // FIXME: None of this "needsWidgetUpdate" related code looks right.
-    if (renderer() && !useFallbackContent())
+    if (renderer() && !useFallbackContent() && !(context.performingReattach && m_protectWidgetDuringReattach))
         setNeedsWidgetUpdate(true);
+
     if (m_isDelayingLoadEvent) {
         m_isDelayingLoadEvent = false;
         document().decrementLoadEventDelayCount();
     }
 
     resetInstance();
 
     if (m_isCapturingMouseEvents) {
         if (Frame* frame = document().frame())
             frame->eventHandler().setCapturingMouseEventsNode(0);
@@ skipping 110 matching lines @@
     } else if (name == hspaceAttr) {
         addHTMLLengthToStyle(style, CSSPropertyMarginLeft, value);
         addHTMLLengthToStyle(style, CSSPropertyMarginRight, value);
     } else if (name == alignAttr) {
         applyAlignmentAttributeToStyle(value, style);
     } else {
         HTMLFrameOwnerElement::collectStyleForPresentationAttribute(name, value, style);
     }
 }
 
+// FIXME: Hack to prevent the plugin from reloading when entering/exiting
+// fullscreen. When plugins are moved out of render objects, this function won't
+// be needed.
+void HTMLPlugInElement::setIsInTopLayer(bool inTopLayer)
+{
+    if (isInTopLayer() == inTopLayer)
+        return;
+    if (renderEmbeddedObject() && !needsWidgetUpdate() && existingRenderWidget())
+        m_protectWidgetDuringReattach = existingRenderWidget()->widget();

[esprehn, 2014/02/11 00:25:16]

This doesn't seem right, what if you have <div><object ...></div>

Now the plugin will reload since it's not the thing that's going into the top
layer, its parent is.

[falken, 2014/02/11 14:39:58]

Ah, good point. How about adding "topLayerChanged" to AttachContext, or else
making Element::setIsInTopLayer traverse descendants and have any
HTMLPlugInElements protect their widgets?

From the breakage caused by the previous patch, it seems reloading the plugin
even when needsWidgetUpdate is false during a reattach is necessary in some
cases. So HTMLPlugInElement somehow needs to know when the reattach was caused
by something entering/exiting top layer.

+    HTMLFrameOwnerElement::setIsInTopLayer(inTopLayer);
+}
+
 void HTMLPlugInElement::defaultEventHandler(Event* event)
 {
     // Firefox seems to use a fake event listener to dispatch events to plug-in
     // (tested with mouse events only). This is observable via different order
     // of events - in Firefox, event listeners specified in HTML attributes
     // fires first, then an event gets dispatched to plug-in, and only then
     // other event listeners fire. Hopefully, this difference does not matter in
     // practice.
 
     // FIXME: Mouse down and scroll events are passed down to plug-in via custom
@@ skipping 234 matching lines @@
     if (root.isOldestAuthorShadowRoot())
         lazyReattachIfAttached();
 }
 
 bool HTMLPlugInElement::useFallbackContent() const
 {
     return hasAuthorShadowRoot();
 }
 
 }