Update renderer to layoutObject in core/html.

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 129 matching lines @@
 {
     if (isDisabledFormControl())
         return false;
     LayoutObject* r = layoutObject();
     return r && (r->isEmbeddedObject() || r->isLayoutPart());
 }
 
 void HTMLPlugInElement::removeAllEventListeners()
 {
     HTMLFrameOwnerElement::removeAllEventListeners();
-    if (LayoutPart* renderer = existingLayoutPart()) {
-        if (Widget* widget = renderer->widget())
+    if (LayoutPart* layoutObject = existingLayoutPart()) {
+        if (Widget* widget = layoutObject->widget())
             widget->eventListenersRemoved();
     }
 }
 
 void HTMLPlugInElement::didMoveToNewDocument(Document& oldDocument)
 {
     if (m_imageLoader)
         m_imageLoader->elementDidMoveToNewDocument();
     HTMLFrameOwnerElement::didMoveToNewDocument(oldDocument);
 }
@@ skipping 23 matching lines @@
 void HTMLPlugInElement::updateWidget()
 {
     RefPtrWillBeRawPtr<HTMLPlugInElement> protector(this);
     updateWidgetInternal();
     if (m_isDelayingLoadEvent) {
         m_isDelayingLoadEvent = false;
         document().decrementLoadEventDelayCount();
     }
 }
 
-void HTMLPlugInElement::requestPluginCreationWithoutRendererIfPossible()
+void HTMLPlugInElement::requestPluginCreationWithoutLayoutObjectIfPossible()
 {
     if (m_serviceType.isEmpty())
         return;
 
     if (!document().frame()
         || !document().frame()->loader().client()->canCreatePluginWithoutRenderer(m_serviceType))
         return;
 
     if (layoutObject() && layoutObject()->isLayoutPart())
         return;
 
-    createPluginWithoutRenderer();
+    createPluginWithoutLayoutObject();
 }
 
-void HTMLPlugInElement::createPluginWithoutRenderer()
+void HTMLPlugInElement::createPluginWithoutLayoutObject()
 {
     ASSERT(document().frame()->loader().client()->canCreatePluginWithoutRenderer(m_serviceType));
 
     KURL url;
     Vector<String> paramNames;
     Vector<String> paramValues;
 
     paramNames.append("type");
     paramValues.append(m_serviceType);
 
@@ skipping 37 matching lines @@
     if (m_NPObject) {
         _NPN_ReleaseObject(m_NPObject);
         m_NPObject = 0;
     }
 
     HTMLFrameOwnerElement::detach(context);
 }
 
 LayoutObject* HTMLPlugInElement::createLayoutObject(const ComputedStyle& style)
 {
-    // Fallback content breaks the DOM->Renderer class relationship of this
+    // Fallback content breaks the DOM->layoutObject class relationship of this
     // class and all superclasses because createObject won't necessarily return
     // a LayoutEmbeddedObject or LayoutPart.
     if (useFallbackContent())
         return LayoutObject::createObject(this, style);
 
     if (isImageType()) {
         LayoutImage* image = new LayoutImage(this);
         image->setImageResource(LayoutImageResource::create());
         return image;
     }
@@ skipping 178 matching lines @@
     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);
 }
 
 LayoutEmbeddedObject* HTMLPlugInElement::layoutEmbeddedObject() const
 {
-    // HTMLObjectElement and HTMLEmbedElement may return arbitrary renderers
+    // HTMLObjectElement and HTMLEmbedElement may return arbitrary layoutObjects
     // when using fallback content.
     if (!layoutObject() || !layoutObject()->isEmbeddedObject())
         return nullptr;
     return toLayoutEmbeddedObject(layoutObject());
 }
 
 // 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)
 {
@@ skipping 31 matching lines @@
     if (shouldUsePlugin(completedURL, mimeType, hasFallbackContent(), useFallback))
         return loadPlugin(completedURL, mimeType, paramNames, paramValues, useFallback, true);
 
     // If the plugin 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);
 }
 
-bool HTMLPlugInElement::loadPlugin(const KURL& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback, bool requireRenderer)
+bool HTMLPlugInElement::loadPlugin(const KURL& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback, bool requireLayoutObject)
 {
     LocalFrame* frame = document().frame();
 
     if (!frame->loader().allowPlugins(AboutToInstantiatePlugin))
         return false;
 
-    LayoutEmbeddedObject* renderer = layoutEmbeddedObject();
-    // FIXME: This code should not depend on renderer!
-    if ((!renderer && requireRenderer) || useFallback)
+    LayoutEmbeddedObject* layoutObject = layoutEmbeddedObject();
+    // FIXME: This code should not depend on layoutObject!
+    if ((!layoutObject && requireLayoutObject) || useFallback)
         return false;
 
     WTF_LOG(Plugins, "%p Plugin 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;
+            FrameLoaderClient::DetachedPluginPolicy policy = requireLayoutObject ? 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(LayoutEmbeddedObject::PluginMissing);
+        if (layoutObject && !layoutObject->showsUnavailablePluginIndicator())
+            layoutObject->setPluginUnavailabilityReason(LayoutEmbeddedObject::PluginMissing);
         setPlaceholder(nullptr);
         return false;
     }
 
     if (placeholder) {
         setPlaceholder(placeholder.release());
         return true;
     }
 
-    if (renderer) {
+    if (layoutObject) {
         setWidget(widget);
         setPersistedPluginWidget(nullptr);
     } else {
         setPersistedPluginWidget(widget.get());
     }
     setPlaceholder(nullptr);
     document().setContainsPlugins();
     scheduleSVGFilterLayerUpdateHack();
     // Make sure any input event handlers introduced by the plugin are taken into account.
     if (Page* page = document().frame()->page()) {
@@ skipping 99 matching lines @@
     return hasOpenShadowRoot();
 }
 
 void HTMLPlugInElement::lazyReattachIfNeeded()
 {
     if (!useFallbackContent() && !usePlaceholderContent() && needsWidgetUpdate() && layoutObject() && !isImageType())
         lazyReattachIfAttached();
 }
 
 }