726ab44340fa2185e9fd7af621520e6daf192973
[WebKit-https.git] / Source / WebCore / html / HTMLPlugInElement.cpp
1 /**
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2000 Stefan Schimanski (1Stein@gmx.de)
5  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  */
22
23 #include "config.h"
24 #include "HTMLPlugInElement.h"
25
26 #include "Attribute.h"
27 #include "Chrome.h"
28 #include "ChromeClient.h"
29 #include "CSSPropertyNames.h"
30 #include "Document.h"
31 #include "Event.h"
32 #include "Frame.h"
33 #include "FrameLoader.h"
34 #include "FrameTree.h"
35 #include "HTMLNames.h"
36 #include "Page.h"
37 #include "PluginViewBase.h"
38 #include "RenderEmbeddedObject.h"
39 #include "RenderSnapshottedPlugIn.h"
40 #include "RenderWidget.h"
41 #include "Settings.h"
42 #include "Widget.h"
43 #include <wtf/UnusedParam.h>
44
45 #if ENABLE(NETSCAPE_PLUGIN_API)
46 #include "npruntime_impl.h"
47 #endif
48
49 namespace WebCore {
50
51 using namespace HTMLNames;
52
53 HTMLPlugInElement::HTMLPlugInElement(const QualifiedName& tagName, Document* doc)
54     : HTMLFrameOwnerElement(tagName, doc)
55     , m_inBeforeLoadEventHandler(false)
56 #if ENABLE(NETSCAPE_PLUGIN_API)
57     , m_NPObject(0)
58 #endif
59     , m_isCapturingMouseEvents(false)
60     , m_displayState(Playing)
61 {
62 }
63
64 HTMLPlugInElement::~HTMLPlugInElement()
65 {
66     ASSERT(!m_instance); // cleared in detach()
67
68 #if ENABLE(NETSCAPE_PLUGIN_API)
69     if (m_NPObject) {
70         _NPN_ReleaseObject(m_NPObject);
71         m_NPObject = 0;
72     }
73 #endif
74 }
75
76 bool HTMLPlugInElement::canProcessDrag() const
77 {
78     const PluginViewBase* plugin = pluginWidget() && pluginWidget()->isPluginViewBase() ? static_cast<const PluginViewBase*>(pluginWidget()) : 0;
79     return plugin ? plugin->canProcessDrag() : false;
80 }
81
82 bool HTMLPlugInElement::willRespondToMouseClickEvents()
83 {
84     if (disabled())
85         return false;
86     RenderObject* r = renderer();
87     if (!r)
88         return false;
89     if (!r->isEmbeddedObject() && !r->isWidget())
90         return false;
91     return true;
92 }
93
94 void HTMLPlugInElement::detach()
95 {
96     m_instance.clear();
97
98     if (m_isCapturingMouseEvents) {
99         if (Frame* frame = document()->frame())
100             frame->eventHandler()->setCapturingMouseEventsNode(0);
101         m_isCapturingMouseEvents = false;
102     }
103
104 #if ENABLE(NETSCAPE_PLUGIN_API)
105     if (m_NPObject) {
106         _NPN_ReleaseObject(m_NPObject);
107         m_NPObject = 0;
108     }
109 #endif
110
111     HTMLFrameOwnerElement::detach();
112 }
113
114 void HTMLPlugInElement::resetInstance()
115 {
116     m_instance.clear();
117 }
118
119 PassScriptInstance HTMLPlugInElement::getInstance()
120 {
121     Frame* frame = document()->frame();
122     if (!frame)
123         return 0;
124
125     // If the host dynamically turns off JavaScript (or Java) we will still return
126     // the cached allocated Bindings::Instance.  Not supporting this edge-case is OK.
127     if (m_instance)
128         return m_instance;
129
130     if (Widget* widget = pluginWidget())
131         m_instance = frame->script()->createScriptInstanceForWidget(widget);
132
133     return m_instance;
134 }
135
136 bool HTMLPlugInElement::guardedDispatchBeforeLoadEvent(const String& sourceURL)
137 {
138     // FIXME: Our current plug-in loading design can't guarantee the following
139     // assertion is true, since plug-in loading can be initiated during layout,
140     // and synchronous layout can be initiated in a beforeload event handler!
141     // See <http://webkit.org/b/71264>.
142     // ASSERT(!m_inBeforeLoadEventHandler);
143     m_inBeforeLoadEventHandler = true;
144     // static_cast is used to avoid a compile error since dispatchBeforeLoadEvent
145     // is intentionally undefined on this class.
146     bool beforeLoadAllowedLoad = static_cast<HTMLFrameOwnerElement*>(this)->dispatchBeforeLoadEvent(sourceURL);
147     m_inBeforeLoadEventHandler = false;
148     return beforeLoadAllowedLoad;
149 }
150
151 Widget* HTMLPlugInElement::pluginWidget() const
152 {
153     if (m_inBeforeLoadEventHandler) {
154         // The plug-in hasn't loaded yet, and it makes no sense to try to load if beforeload handler happened to touch the plug-in element.
155         // That would recursively call beforeload for the same element.
156         return 0;
157     }
158
159     RenderWidget* renderWidget = renderWidgetForJSBindings();
160     if (!renderWidget)
161         return 0;
162
163     return renderWidget->widget();
164 }
165
166 bool HTMLPlugInElement::isPresentationAttribute(const QualifiedName& name) const
167 {
168     if (name == widthAttr || name == heightAttr || name == vspaceAttr || name == hspaceAttr || name == alignAttr)
169         return true;
170     return HTMLFrameOwnerElement::isPresentationAttribute(name);
171 }
172
173 void HTMLPlugInElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStylePropertySet* style)
174 {
175     if (name == widthAttr)
176         addHTMLLengthToStyle(style, CSSPropertyWidth, value);
177     else if (name == heightAttr)
178         addHTMLLengthToStyle(style, CSSPropertyHeight, value);
179     else if (name == vspaceAttr) {
180         addHTMLLengthToStyle(style, CSSPropertyMarginTop, value);
181         addHTMLLengthToStyle(style, CSSPropertyMarginBottom, value);
182     } else if (name == hspaceAttr) {
183         addHTMLLengthToStyle(style, CSSPropertyMarginLeft, value);
184         addHTMLLengthToStyle(style, CSSPropertyMarginRight, value);
185     } else if (name == alignAttr)
186         applyAlignmentAttributeToStyle(value, style);
187     else
188         HTMLFrameOwnerElement::collectStyleForPresentationAttribute(name, value, style);
189 }
190
191 void HTMLPlugInElement::defaultEventHandler(Event* event)
192 {
193     // Firefox seems to use a fake event listener to dispatch events to plug-in (tested with mouse events only).
194     // This is observable via different order of events - in Firefox, event listeners specified in HTML attributes fires first, then an event
195     // gets dispatched to plug-in, and only then other event listeners fire. Hopefully, this difference does not matter in practice.
196
197     // FIXME: Mouse down and scroll events are passed down to plug-in via custom code in EventHandler; these code paths should be united.
198
199     RenderObject* r = renderer();
200     if (r && r->isEmbeddedObject()) {
201         if (toRenderEmbeddedObject(r)->showsUnavailablePluginIndicator()) {
202             toRenderEmbeddedObject(r)->handleUnavailablePluginIndicatorEvent(event);
203             return;
204         }
205
206         if (r->isSnapshottedPlugIn() && displayState() < Restarting) {
207             toRenderSnapshottedPlugIn(r)->handleEvent(event);
208             HTMLFrameOwnerElement::defaultEventHandler(event);
209             return;
210         }
211
212         if (displayState() < Playing)
213             return;
214     }
215
216     if (!r || !r->isWidget())
217         return;
218     RefPtr<Widget> widget = toRenderWidget(r)->widget();
219     if (!widget)
220         return;
221     widget->handleEvent(event);
222     if (event->defaultHandled())
223         return;
224     HTMLFrameOwnerElement::defaultEventHandler(event);
225 }
226
227 bool HTMLPlugInElement::isKeyboardFocusable(KeyboardEvent* event) const
228 {
229     UNUSED_PARAM(event);
230     if (!document()->page())
231         return false;
232
233     const PluginViewBase* plugin = pluginWidget() && pluginWidget()->isPluginViewBase() ? static_cast<const PluginViewBase*>(pluginWidget()) : 0;
234     if (plugin)
235         return plugin->supportsKeyboardFocus();
236
237     return false;
238 }
239
240 bool HTMLPlugInElement::isPluginElement() const
241 {
242     return true;
243 }
244
245 #if ENABLE(NETSCAPE_PLUGIN_API)
246
247 NPObject* HTMLPlugInElement::getNPObject()
248 {
249     ASSERT(document()->frame());
250     if (!m_NPObject)
251         m_NPObject = document()->frame()->script()->createScriptObjectForPluginElement(this);
252     return m_NPObject;
253 }
254
255 #endif /* ENABLE(NETSCAPE_PLUGIN_API) */
256
257 }