Move members of HTMLPlugInImageElement to HTMLPlugInElement, part 4.

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 19 matching lines @@
 #include "core/dom/Document.h"
 #include "core/dom/PostAttachCallbacks.h"
 #include "core/events/Event.h"
 #include "core/html/HTMLImageLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/page/EventHandler.h"
 #include "core/frame/Frame.h"
 #include "core/platform/MIMETypeFromURL.h"
 #include "core/plugins/PluginView.h"
 #include "core/rendering/RenderEmbeddedObject.h"
+#include "core/rendering/RenderImage.h"
 #include "core/rendering/RenderWidget.h"
 #include "platform/Widget.h"
 #include "wtf/UnusedParam.h"
 
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 HTMLPlugInElement::HTMLPlugInElement(const QualifiedName& tagName, Document& doc, bool createdByParser, PreferPlugInsForImagesOption preferPlugInsForImagesOption)
     : HTMLFrameOwnerElement(tagName, doc)
     , 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)
 {
+    setHasCustomStyleCallbacks();
 }
 
 HTMLPlugInElement::~HTMLPlugInElement()
 {
     ASSERT(!m_pluginWrapper); // cleared in detach()
 
     if (m_NPObject) {
         _NPN_ReleaseObject(m_NPObject);
         m_NPObject = 0;
     }
@@ skipping 86 matching lines @@
     }
 
     if (m_NPObject) {
         _NPN_ReleaseObject(m_NPObject);
         m_NPObject = 0;
     }
 
     HTMLFrameOwnerElement::detach(context);
 }
 
+RenderObject* HTMLPlugInElement::createRenderer(RenderStyle* style)
+{
+    // Fallback content breaks the DOM->Renderer class relationship of this
+    // class and all superclasses because createObject won't necessarily
+    // return a RenderEmbeddedObject, RenderPart or even RenderWidget.
+    if (useFallbackContent())
+        return RenderObject::createObject(this, style);
+
+    if (isImageType()) {
+        RenderImage* image = new RenderImage(this);
+        image->setImageResource(RenderImageResource::create());
+        return image;
+    }
+
+    return new RenderEmbeddedObject(this);
+}
+
+void HTMLPlugInElement::willRecalcStyle(StyleRecalcChange)
+{
+    // FIXME: Why is this necessary? Manual re-attach is almost always wrong.
+    if (!useFallbackContent() && needsWidgetUpdate() && renderer() && !isImageType())
+        reattach();
+}
+
+void HTMLPlugInElement::finishParsingChildren()
+{
+    HTMLFrameOwnerElement::finishParsingChildren();
+    if (useFallbackContent())
+        return;
+
+    setNeedsWidgetUpdate(true);
+    if (inDocument())
+        setNeedsStyleRecalc();
+}
+
 void HTMLPlugInElement::resetInstance()
 {
     m_pluginWrapper.clear();
 }
 
 SharedPersistent<v8::Object>* HTMLPlugInElement::pluginWrapper()
 {
     Frame* frame = document().frame();
     if (!frame)
         return 0;
@@ skipping 152 matching lines @@
 
 RenderEmbeddedObject* HTMLPlugInElement::renderEmbeddedObject() const
 {
     // HTMLObjectElement and HTMLEmbedElement may return arbitrary renderers
     // when using fallback content.
     if (!renderer() || !renderer()->isEmbeddedObject())
         return 0;
     return toRenderEmbeddedObject(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;
+    return document().frame()->isURLAllowed(completeURL);
 }
+
+// We don't use m_url, or m_serviceType as they may not be the final values
+// that <object> uses depending on <param> values.
+bool HTMLPlugInElement::wouldLoadAsNetscapePlugin(const String& url, const String& serviceType)
+{
+    ASSERT(document().frame());
+    KURL completedURL;
+    if (!url.isEmpty())
+        completedURL = document().completeURL(url);
+    return document().frame()->loader().client()->objectContentType(completedURL, serviceType, shouldPreferPlugInsForImages()) == ObjectContentNetscapePlugin;
+}
+
+}