[Qt] Remove unused code path in PluginView
[WebKit-https.git] / Source / WebCore / plugins / PluginView.h
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
3  * Copyright (C) 2008 Collabora Ltd. All rights reserved.
4  * Copyright (C) 2009 Girish Ramakrishnan <girish@forwardbias.in>
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
26  */
27
28 #ifndef PluginView_h
29 #define PluginView_h
30
31 #include "FrameLoadRequest.h"
32 #include "IntRect.h"
33 #include "MediaCanStartListener.h"
34 #include "PluginViewBase.h"
35 #include "ResourceRequest.h"
36 #include "Timer.h"
37 #include <wtf/HashMap.h>
38 #include <wtf/HashSet.h>
39 #include <wtf/OwnPtr.h>
40 #include <wtf/PassRefPtr.h>
41 #include <wtf/RefPtr.h>
42 #include <wtf/Vector.h>
43 #include <wtf/text/CString.h>
44
45 #if ENABLE(NETSCAPE_PLUGIN_API)
46 #include "PluginStream.h"
47 #include "npruntime_internal.h"
48 #endif
49
50 #if OS(WINDOWS) && (PLATFORM(GTK) || PLATFORM(QT))
51 typedef struct HWND__* HWND;
52 typedef HWND PlatformPluginWidget;
53 #else
54 typedef PlatformWidget PlatformPluginWidget;
55 #endif
56 #if PLATFORM(QT)
57 #if USE(TEXTURE_MAPPER)
58 #include "TextureMapperPlatformLayer.h"
59 #endif
60
61 #include <QImage>
62 QT_BEGIN_NAMESPACE
63 class QPainter;
64 QT_END_NAMESPACE
65 #endif
66 #if PLATFORM(GTK)
67 typedef struct _GtkSocket GtkSocket;
68 #endif
69
70 namespace JSC {
71     namespace Bindings {
72         class Instance;
73     }
74 }
75
76 namespace WebCore {
77     class Frame;
78     class Image;
79     class HTMLPlugInElement;
80     class KeyboardEvent;
81     class MouseEvent;
82     class KURL;
83 #if OS(WINDOWS) && ENABLE(NETSCAPE_PLUGIN_API)
84     class PluginMessageThrottlerWin;
85 #endif
86     class PluginPackage;
87     class PluginRequest;
88     class PluginStream;
89     class ResourceError;
90     class ResourceResponse;
91     class WheelEvent;
92
93     enum PluginStatus {
94         PluginStatusCanNotFindPlugin,
95         PluginStatusCanNotLoadPlugin,
96         PluginStatusLoadedSuccessfully
97     };
98
99     class PluginRequest {
100         WTF_MAKE_NONCOPYABLE(PluginRequest); WTF_MAKE_FAST_ALLOCATED;
101     public:
102         PluginRequest(const FrameLoadRequest& frameLoadRequest, bool sendNotification, void* notifyData, bool shouldAllowPopups)
103             : m_frameLoadRequest(frameLoadRequest)
104             , m_notifyData(notifyData)
105             , m_sendNotification(sendNotification)
106             , m_shouldAllowPopups(shouldAllowPopups) { }
107     public:
108         const FrameLoadRequest& frameLoadRequest() const { return m_frameLoadRequest; }
109         void* notifyData() const { return m_notifyData; }
110         bool sendNotification() const { return m_sendNotification; }
111         bool shouldAllowPopups() const { return m_shouldAllowPopups; }
112     private:
113         FrameLoadRequest m_frameLoadRequest;
114         void* m_notifyData;
115         bool m_sendNotification;
116         bool m_shouldAllowPopups;
117     };
118
119     class PluginManualLoader {
120     public:
121         virtual ~PluginManualLoader() {}
122         virtual void didReceiveResponse(const ResourceResponse&) = 0;
123         virtual void didReceiveData(const char*, int) = 0;
124         virtual void didFinishLoading() = 0;
125         virtual void didFail(const ResourceError&) = 0;
126     };
127
128     class PluginView : public PluginViewBase
129 #if ENABLE(NETSCAPE_PLUGIN_API)
130                      , private PluginStreamClient
131 #endif
132                      , public PluginManualLoader
133                      , private MediaCanStartListener {
134     public:
135         static PassRefPtr<PluginView> create(Frame* parentFrame, const IntSize&, HTMLPlugInElement*, const KURL&, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually);
136         virtual ~PluginView();
137
138         PluginPackage* plugin() const { return m_plugin.get(); }
139 #if ENABLE(NETSCAPE_PLUGIN_API)
140         NPP instance() const { return m_instance; }
141 #endif
142
143         void setNPWindowRect(const IntRect&);
144         static PluginView* currentPluginView();
145
146 #if ENABLE(NETSCAPE_PLUGIN_API)
147         NPObject* npObject();
148 #endif
149         PassRefPtr<JSC::Bindings::Instance> bindingInstance();
150
151         PluginStatus status() const { return m_status; }
152
153 #if ENABLE(NETSCAPE_PLUGIN_API)
154         // NPN functions
155         NPError getURLNotify(const char* url, const char* target, void* notifyData);
156         NPError getURL(const char* url, const char* target);
157         NPError postURLNotify(const char* url, const char* target, uint32_t len, const char* but, NPBool file, void* notifyData);
158         NPError postURL(const char* url, const char* target, uint32_t len, const char* but, NPBool file);
159         NPError newStream(NPMIMEType type, const char* target, NPStream** stream);
160         int32_t write(NPStream* stream, int32_t len, void* buffer);
161         NPError destroyStream(NPStream* stream, NPReason reason);
162 #endif
163         const char* userAgent();
164 #if ENABLE(NETSCAPE_PLUGIN_API)
165         static const char* userAgentStatic();
166 #endif
167         void status(const char* message);
168         
169 #if ENABLE(NETSCAPE_PLUGIN_API)
170         NPError getValue(NPNVariable variable, void* value);
171         static NPError getValueStatic(NPNVariable variable, void* value);
172         NPError setValue(NPPVariable variable, void* value);
173         NPError getValueForURL(NPNURLVariable variable, const char* url, char** value, uint32_t* len);
174         NPError setValueForURL(NPNURLVariable variable, const char* url, const char* value, uint32_t len);
175         NPError getAuthenticationInfo(const char* protocol, const char* host, int32_t port, const char* scheme, const char* realm, char** username, uint32_t* ulen, char** password, uint32_t* plen);
176         void invalidateRect(NPRect*);
177         void invalidateRegion(NPRegion);
178 #endif
179         void forceRedraw();
180         void pushPopupsEnabledState(bool state);
181         void popPopupsEnabledState();
182
183         virtual void invalidateRect(const IntRect&);
184
185         bool arePopupsAllowed() const;
186
187         void setJavaScriptPaused(bool);
188
189         void privateBrowsingStateChanged(bool);
190
191         void disconnectStream(PluginStream*);
192         void streamDidFinishLoading(PluginStream* stream) { disconnectStream(stream); }
193
194         // Widget functions
195         virtual void setFrameRect(const IntRect&);
196         virtual void frameRectsChanged();
197         virtual void setFocus(bool);
198         virtual void show();
199         virtual void hide();
200         virtual void paint(GraphicsContext*, const IntRect&);
201         virtual void clipRectChanged() OVERRIDE;
202
203         // This method is used by plugins on all platforms to obtain a clip rect that includes clips set by WebCore,
204         // e.g., in overflow:auto sections.  The clip rects coordinates are in the containing window's coordinate space.
205         // This clip includes any clips that the widget itself sets up for its children.
206         IntRect windowClipRect() const;
207
208         virtual void handleEvent(Event*);
209         virtual void setParent(ScrollView*);
210         virtual void setParentVisible(bool);
211
212         virtual bool isPluginView() const OVERRIDE { return true; }
213
214         Frame* parentFrame() const { return m_parentFrame.get(); }
215
216         void focusPluginElement();
217
218         const String& pluginsPage() const { return m_pluginsPage; }
219         const String& mimeType() const { return m_mimeType; }
220         const KURL& url() const { return m_url; }
221
222 #if defined(XP_MACOSX) && ENABLE(NETSCAPE_PLUGIN_API)
223         bool popUpContextMenu(NPMenu*);
224 #endif
225
226 #if OS(WINDOWS) && ENABLE(NETSCAPE_PLUGIN_API)
227         static LRESULT CALLBACK PluginViewWndProc(HWND, UINT, WPARAM, LPARAM);
228         LRESULT wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
229         WNDPROC pluginWndProc() const { return m_pluginWndProc; }
230 #endif
231
232         // Used for manual loading
233         void didReceiveResponse(const ResourceResponse&);
234         void didReceiveData(const char*, int);
235         void didFinishLoading();
236         void didFail(const ResourceError&);
237
238         static bool isCallingPlugin();
239
240         bool start();
241
242 #if ENABLE(NETSCAPE_PLUGIN_API)
243         static void keepAlive(NPP);
244 #endif
245         void keepAlive();
246
247 #if PLATFORM(QT) && ENABLE(NETSCAPE_PLUGIN_API) && defined(XP_UNIX)
248         // PluginViewQt (X11) needs a few workarounds when running under DRT
249         static void setIsRunningUnderDRT(bool flag) { s_isRunningUnderDRT = flag; }
250 #endif
251
252     private:
253         PluginView(Frame* parentFrame, const IntSize&, PluginPackage*, HTMLPlugInElement*, const KURL&, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually);
254
255         void setParameters(const Vector<String>& paramNames, const Vector<String>& paramValues);
256         bool startOrAddToUnstartedList();
257         void init();
258         bool platformStart();
259         void stop();
260         void platformDestroy();
261         static void setCurrentPluginView(PluginView*);
262 #if ENABLE(NETSCAPE_PLUGIN_API)
263         NPError load(const FrameLoadRequest&, bool sendNotification, void* notifyData);
264         NPError handlePost(const char* url, const char* target, uint32_t len, const char* buf, bool file, void* notifyData, bool sendNotification, bool allowHeaders);
265         NPError handlePostReadFile(Vector<char>& buffer, uint32_t len, const char* buf);
266 #endif
267         static void freeStringArray(char** stringArray, int length);
268         void setCallingPlugin(bool) const;
269
270         void invalidateWindowlessPluginRect(const IntRect&);
271
272         virtual void mediaCanStart();
273
274 #if OS(WINDOWS) && ENABLE(NETSCAPE_PLUGIN_API)
275         void paintWindowedPluginIntoContext(GraphicsContext*, const IntRect&);
276         static HDC WINAPI hookedBeginPaint(HWND, PAINTSTRUCT*);
277         static BOOL WINAPI hookedEndPaint(HWND, const PAINTSTRUCT*);
278 #endif
279
280 #if ENABLE(NETSCAPE_PLUGIN_API)
281         static bool platformGetValueStatic(NPNVariable variable, void* value, NPError* result);
282         bool platformGetValue(NPNVariable variable, void* value, NPError* result);
283 #endif
284
285         RefPtr<Frame> m_parentFrame;
286         RefPtr<PluginPackage> m_plugin;
287         HTMLPlugInElement* m_element;
288         bool m_isStarted;
289         KURL m_url;
290         PluginStatus m_status;
291         Vector<IntRect> m_invalidRects;
292
293         void performRequest(PluginRequest*);
294         void scheduleRequest(PassOwnPtr<PluginRequest>);
295         void requestTimerFired(Timer<PluginView>*);
296         void invalidateTimerFired(Timer<PluginView>*);
297         Timer<PluginView> m_requestTimer;
298         Timer<PluginView> m_invalidateTimer;
299
300         void popPopupsStateTimerFired(Timer<PluginView>*);
301         Timer<PluginView> m_popPopupsStateTimer;
302
303         void lifeSupportTimerFired(Timer<PluginView>*);
304         Timer<PluginView> m_lifeSupportTimer;
305
306 #if ENABLE(NETSCAPE_PLUGIN_API)
307         bool dispatchNPEvent(NPEvent&);
308 #endif
309 #if defined(XP_MACOSX) && ENABLE(NETSCAPE_PLUGIN_API)
310         int16_t dispatchNPCocoaEvent(NPCocoaEvent&);
311         bool m_updatedCocoaTextInputRequested;
312         bool m_keyDownSent;
313         uint16_t m_disregardKeyUpCounter;
314 #endif
315
316 #if defined(XP_MACOSX)
317         void handleWheelEvent(WheelEvent*);
318 #endif
319         void updatePluginWidget();
320         void paintMissingPluginIcon(GraphicsContext*, const IntRect&);
321
322         void handleKeyboardEvent(KeyboardEvent*);
323         void handleMouseEvent(MouseEvent*);
324 #if defined(XP_UNIX) && ENABLE(NETSCAPE_PLUGIN_API)
325         void handleFocusInEvent();
326         void handleFocusOutEvent();
327 #endif
328
329 #if OS(WINDOWS)
330         void paintIntoTransformedContext(HDC);
331         PassRefPtr<Image> snapshot();
332 #endif
333
334         int m_mode;
335         int m_paramCount;
336         char** m_paramNames;
337         char** m_paramValues;
338         String m_pluginsPage;
339
340         String m_mimeType;
341         WTF::CString m_userAgent;
342
343 #if ENABLE(NETSCAPE_PLUGIN_API)
344         NPP m_instance;
345         NPP_t m_instanceStruct;
346         NPWindow m_npWindow;
347 #endif
348
349         Vector<bool, 4> m_popupStateStack;
350
351         HashSet<RefPtr<PluginStream> > m_streams;
352         Vector<OwnPtr<PluginRequest> > m_requests;
353
354         bool m_isWindowed;
355         bool m_isTransparent;
356         bool m_haveInitialized;
357         bool m_isWaitingToStart;
358
359 #if defined(XP_UNIX)
360         bool m_needsXEmbed;
361 #endif
362
363 #if OS(WINDOWS) && ENABLE(NETSCAPE_PLUGIN_API)
364         OwnPtr<PluginMessageThrottlerWin> m_messageThrottler;
365         WNDPROC m_pluginWndProc;
366         unsigned m_lastMessage;
367         bool m_isCallingPluginWndProc;
368         HDC m_wmPrintHDC;
369         bool m_haveUpdatedPluginWidget;
370 #endif
371
372 #if ((PLATFORM(GTK) || PLATFORM(QT)) && OS(WINDOWS)) || PLATFORM(EFL)
373         // On Mac OSX and Qt/Windows the plugin does not have its own native widget,
374         // but is using the containing window as its reference for positioning/painting.
375         PlatformPluginWidget m_window;
376 public:
377         PlatformPluginWidget platformPluginWidget() const { return m_window; }
378         void setPlatformPluginWidget(PlatformPluginWidget widget) { m_window = widget; }
379 #else
380 public:
381         void setPlatformPluginWidget(PlatformPluginWidget widget) { setPlatformWidget(widget); }
382         PlatformPluginWidget platformPluginWidget() const { return platformWidget(); }
383 #endif
384
385 private:
386
387 #if defined(XP_UNIX) || PLATFORM(GTK)
388         void setNPWindowIfNeeded();
389 #elif defined(XP_MACOSX)
390         NP_CGContext m_npCgContext;
391         CGContextRef m_contextRef;
392
393         void setNPWindowIfNeeded();
394 #endif
395
396 #if defined(XP_UNIX) && ENABLE(NETSCAPE_PLUGIN_API)
397         bool m_hasPendingGeometryChange;
398         Pixmap m_drawable;
399         Visual* m_visual;
400         Colormap m_colormap;
401         Display* m_pluginDisplay;
402
403         void initXEvent(XEvent* event);
404 #endif
405
406 #if PLATFORM(QT)
407 #if defined(XP_UNIX) && ENABLE(NETSCAPE_PLUGIN_API)
408         static bool s_isRunningUnderDRT;
409         static void setXKeyEventSpecificFields(XEvent*, KeyboardEvent*);
410         void paintUsingXPixmap(QPainter* painter, const QRect &exposedRect);
411         QWebPageClient* platformPageClient() const;
412 #endif
413 #endif // PLATFORM(QT)
414
415 #if PLATFORM(GTK)
416         static gboolean plugRemovedCallback(GtkSocket*, PluginView*);
417         static void plugAddedCallback(GtkSocket*, PluginView*);
418         void updateWidgetAllocationAndClip();
419         bool m_plugAdded;
420         IntRect m_delayedAllocation;
421 #endif
422
423         IntRect m_clipRect; // The clip rect to apply to a windowed plug-in
424         IntRect m_windowRect; // Our window rect.
425
426         bool m_loadManually;
427         RefPtr<PluginStream> m_manualStream;
428
429         bool m_isJavaScriptPaused;
430
431         bool m_haveCalledSetWindow;
432
433         static PluginView* s_currentPluginView;
434     };
435
436 inline PluginView* toPluginView(Widget* widget)
437 {
438     ASSERT(!widget || widget->isPluginView());
439     return static_cast<PluginView*>(widget);
440 }
441
442 inline const PluginView* toPluginView(const Widget* widget)
443 {
444     ASSERT(!widget || widget->isPluginView());
445     return static_cast<const PluginView*>(widget);
446 }
447
448 // This will catch anyone doing an unnecessary cast.
449 void toPluginView(const PluginView*);
450
451 } // namespace WebCore
452
453 #endif