Move and rename RenderEmbeddedObject and RenderIFrame.

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 20 matching lines @@
 #include "core/dom/Node.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/events/Event.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/HTMLContentElement.h"
 #include "core/html/HTMLImageLoader.h"
 #include "core/html/PluginDocument.h"
+#include "core/layout/LayoutEmbeddedObject.h"
 #include "core/layout/LayoutImage.h"
 #include "core/layout/LayoutPart.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/loader/MixedContentChecker.h"
 #include "core/page/EventHandler.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 #include "core/plugins/PluginPlaceholder.h"
 #include "core/plugins/PluginView.h"
 #include "core/rendering/RenderBlockFlow.h"
-#include "core/rendering/RenderEmbeddedObject.h"
 #include "platform/Logging.h"
 #include "platform/MIMETypeFromURL.h"
 #include "platform/MIMETypeRegistry.h"
 #include "platform/Widget.h"
 #include "platform/plugins/PluginData.h"
 #include "public/platform/WebURLRequest.h"
 
 namespace blink {
 
 using namespace HTMLNames;
@@ skipping 103 matching lines @@
     HTMLFrameOwnerElement::attach(context);
 
     if (!renderer() || useFallbackContent())
         return;
 
     if (isImageType()) {
         if (!m_imageLoader)
             m_imageLoader = HTMLImageLoader::create(this);
         m_imageLoader->updateFromElement();
     } else if (needsWidgetUpdate()
-        && renderEmbeddedObject()
-        && !renderEmbeddedObject()->showsUnavailablePluginIndicator()
+        && layoutEmbeddedObject()
+        && !layoutEmbeddedObject()->showsUnavailablePluginIndicator()
         && !wouldLoadAsNetscapePlugin(m_url, m_serviceType)
         && !m_isDelayingLoadEvent) {
         m_isDelayingLoadEvent = true;
         document().incrementLoadEventDelayCount();
         document().loadPluginsSoon();
     }
 }
 
 void HTMLPlugInElement::updateWidget()
 {
@@ skipping 73 matching lines @@
         m_NPObject = 0;
     }
 
     HTMLFrameOwnerElement::detach(context);
 }
 
 LayoutObject* HTMLPlugInElement::createRenderer(const LayoutStyle& style)
 {
     // Fallback content breaks the DOM->Renderer class relationship of this
     // class and all superclasses because createObject won't necessarily return
-    // a RenderEmbeddedObject or LayoutPart.
+    // a LayoutEmbeddedObject or LayoutPart.
     if (useFallbackContent())
         return LayoutObject::createObject(this, style);
 
     if (isImageType()) {
         LayoutImage* image = new LayoutImage(this);
         image->setImageResource(LayoutImageResource::create());
         return image;
     }
 
     if (usePlaceholderContent())
         return new RenderBlockFlow(this);
 
-    return new RenderEmbeddedObject(this);
+    return new LayoutEmbeddedObject(this);
 }
 
 void HTMLPlugInElement::finishParsingChildren()
 {
     HTMLFrameOwnerElement::finishParsingChildren();
     if (useFallbackContent())
         return;
 
     setNeedsWidgetUpdate(true);
     if (inDocument())
@@ skipping 77 matching lines @@
     // 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
     // code in EventHandler; these code paths should be united.
 
     LayoutObject* r = renderer();
     if (!r || !r->isLayoutPart())
         return;
     if (r->isEmbeddedObject()) {
-        if (toRenderEmbeddedObject(r)->showsUnavailablePluginIndicator())
+        if (toLayoutEmbeddedObject(r)->showsUnavailablePluginIndicator())
             return;
     }
     RefPtrWillBeRawPtr<Widget> widget = toLayoutPart(r)->widget();
     if (!widget)
         return;
     widget->handleEvent(event);
     if (event->defaultHandled())
         return;
     HTMLFrameOwnerElement::defaultEventHandler(event);
 }
@@ skipping 31 matching lines @@
     return true;
 }
 
 bool HTMLPlugInElement::rendererIsFocusable() const
 {
     if (HTMLFrameOwnerElement::supportsFocus() && HTMLFrameOwnerElement::rendererIsFocusable())
         return true;
 
     if (useFallbackContent() || !renderer() || !renderer()->isEmbeddedObject())
         return false;
-    return !toRenderEmbeddedObject(renderer())->showsUnavailablePluginIndicator();
+    return !toLayoutEmbeddedObject(renderer())->showsUnavailablePluginIndicator();
 }
 
 NPObject* HTMLPlugInElement::getNPObject()
 {
     ASSERT(document().frame());
     if (!m_NPObject)
         m_NPObject = document().frame()->script().createScriptObjectForPluginElement(this);
     return m_NPObject;
 }
 
@@ skipping 11 matching lines @@
         m_serviceType = mimeTypeFromDataURL(m_url);
 
     if (LocalFrame* frame = document().frame()) {
         KURL completedURL = document().completeURL(m_url);
         return frame->loader().client()->objectContentType(completedURL, m_serviceType, shouldPreferPlugInsForImages()) == ObjectContentImage;
     }
 
     return Image::supportsType(m_serviceType);
 }
 
-RenderEmbeddedObject* HTMLPlugInElement::renderEmbeddedObject() const
+LayoutEmbeddedObject* HTMLPlugInElement::layoutEmbeddedObject() const
 {
     // HTMLObjectElement and HTMLEmbedElement may return arbitrary renderers
     // when using fallback content.
     if (!renderer() || !renderer()->isEmbeddedObject())
         return nullptr;
-    return toRenderEmbeddedObject(renderer());
+    return toLayoutEmbeddedObject(renderer());
 }
 
 // We don't use m_url, as it may not be the final URL that the object loads,
 // depending on <param> values.
 bool HTMLPlugInElement::allowedToLoadFrameURL(const String& url)
 {
     KURL completeURL = document().completeURL(url);
     if (contentFrame() && protocolIsJavaScript(completeURL)
         && !document().securityOrigin()->canAccess(contentDocument()->securityOrigin()))
         return false;
@@ skipping 13 matching lines @@
 
 bool HTMLPlugInElement::requestObject(const String& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues)
 {
     if (url.isEmpty() && mimeType.isEmpty())
         return false;
 
     if (protocolIsJavaScript(url))
         return false;
 
     // FIXME: None of this code should use renderers!
-    RenderEmbeddedObject* renderer = renderEmbeddedObject();
+    LayoutEmbeddedObject* renderer = layoutEmbeddedObject();
     ASSERT(renderer);
     if (!renderer)
         return false;
 
     KURL completedURL = document().completeURL(url);
     if (!pluginIsLoadable(completedURL, mimeType))
         return false;
 
     bool useFallback;
     bool requireRenderer = true;
     if (shouldUsePlugin(completedURL, mimeType, hasFallbackContent(), useFallback))
         return loadPlugin(completedURL, mimeType, paramNames, paramValues, useFallback, requireRenderer);
 
     // If the plug-in element already contains a subframe,
     // loadOrRedirectSubframe will re-use it. Otherwise, it will create a new
     // frame and set it as the LayoutPart's widget, causing what was previously
     // in the widget to be torn down.
     return loadOrRedirectSubframe(completedURL, getNameAttribute(), true, CheckContentSecurityPolicy);
 }
 
 bool HTMLPlugInElement::loadPlugin(const KURL& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback, bool requireRenderer)
 {
     LocalFrame* frame = document().frame();
 
     if (!frame->loader().allowPlugins(AboutToInstantiatePlugin))
         return false;
 
-    RenderEmbeddedObject* renderer = renderEmbeddedObject();
+    LayoutEmbeddedObject* renderer = layoutEmbeddedObject();
     // FIXME: This code should not depend on renderer!
     if ((!renderer && requireRenderer) || useFallback)
         return false;
 
     WTF_LOG(Plugins, "%p Plug-in URL: %s", this, m_url.utf8().data());
     WTF_LOG(Plugins, "   Loaded URL: %s", url.string().utf8().data());
     m_loadedUrl = url;
 
     OwnPtrWillBeRawPtr<PluginPlaceholder> placeholder = nullptr;
     RefPtrWillBeRawPtr<Widget> widget = m_persistedPluginWidget;
     if (!widget) {
         bool loadManually = document().isPluginDocument() && !document().containsPlugins();
         placeholder = frame->loader().client()->createPluginPlaceholder(document(), url, paramNames, paramValues, mimeType, loadManually);
         if (!placeholder) {
             FrameLoaderClient::DetachedPluginPolicy policy = requireRenderer ? FrameLoaderClient::FailOnDetachedPlugin : FrameLoaderClient::AllowDetachedPlugin;
             widget = frame->loader().client()->createPlugin(this, url, paramNames, paramValues, mimeType, loadManually, policy);
         }
     }
 
     if (!placeholder && !widget) {
         if (renderer && !renderer->showsUnavailablePluginIndicator())
-            renderer->setPluginUnavailabilityReason(RenderEmbeddedObject::PluginMissing);
+            renderer->setPluginUnavailabilityReason(LayoutEmbeddedObject::PluginMissing);
         setPlaceholder(nullptr);
         return false;
     }
 
     if (placeholder) {
         setPlaceholder(placeholder.release());
         return true;
     }
 
     if (renderer) {
@@ skipping 72 matching lines @@
     if (!document().securityOrigin()->canDisplay(url)) {
         FrameLoader::reportLocalLoadFailed(frame, url.string());
         return false;
     }
 
     AtomicString declaredMimeType = document().isPluginDocument() && document().ownerElement() ?
         document().ownerElement()->fastGetAttribute(HTMLNames::typeAttr) :
         fastGetAttribute(HTMLNames::typeAttr);
     if (!document().contentSecurityPolicy()->allowObjectFromSource(url)
         || !document().contentSecurityPolicy()->allowPluginType(mimeType, declaredMimeType, url)) {
-        renderEmbeddedObject()->setPluginUnavailabilityReason(RenderEmbeddedObject::PluginBlockedByContentSecurityPolicy);
+        layoutEmbeddedObject()->setPluginUnavailabilityReason(LayoutEmbeddedObject::PluginBlockedByContentSecurityPolicy);
         return false;
     }
 
     return !MixedContentChecker::shouldBlockFetch(frame, WebURLRequest::RequestContextObject, WebURLRequest::FrameTypeNone, url);
 }
 
 void HTMLPlugInElement::didAddUserAgentShadowRoot(ShadowRoot&)
 {
     userAgentShadowRoot()->appendChild(HTMLContentElement::create(document()));
 }
@@ skipping 13 matching lines @@
     return hasAuthorShadowRoot();
 }
 
 void HTMLPlugInElement::lazyReattachIfNeeded()
 {
     if (!useFallbackContent() && !usePlaceholderContent() && needsWidgetUpdate() && renderer() && !isImageType())
         lazyReattachIfAttached();
 }
 
 }