Revert "2010-03-25 Laszlo Gombos <laszlo.1.gombos@nokia.com>"
[WebKit-https.git] / 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 "CString.h"
32 #include "FrameLoadRequest.h"
33 #include "HaltablePlugin.h"
34 #include "IntRect.h"
35 #include "MediaCanStartListener.h"
36 #include "PluginStream.h"
37 #include "ResourceRequest.h"
38 #include "Timer.h"
39 #include "Widget.h"
40 #include "npruntime_internal.h"
41 #include <wtf/HashMap.h>
42 #include <wtf/HashSet.h>
43 #include <wtf/OwnPtr.h>
44 #include <wtf/PassRefPtr.h>
45 #include <wtf/RefPtr.h>
46 #include <wtf/Vector.h>
47
48 #if OS(WINDOWS) && (PLATFORM(QT) || PLATFORM(WX))
49 typedef struct HWND__* HWND;
50 typedef HWND PlatformPluginWidget;
51 #else
52 typedef PlatformWidget PlatformPluginWidget;
53 #if defined(XP_MACOSX) && PLATFORM(QT)
54 #include <QPixmap>
55 #endif
56 #endif
57
58 namespace JSC {
59     namespace Bindings {
60         class Instance;
61     }
62 }
63
64 namespace WebCore {
65     class Element;
66     class Frame;
67     class Image;
68     class KeyboardEvent;
69     class MouseEvent;
70     class KURL;
71 #if OS(WINDOWS) && ENABLE(NETSCAPE_PLUGIN_API)
72     class PluginMessageThrottlerWin;
73 #endif
74     class PluginPackage;
75     class PluginRequest;
76     class PluginStream;
77     class ResourceError;
78     class ResourceResponse;
79
80     enum PluginStatus {
81         PluginStatusCanNotFindPlugin,
82         PluginStatusCanNotLoadPlugin,
83         PluginStatusLoadedSuccessfully
84     };
85
86     class PluginRequest : public Noncopyable {
87     public:
88         PluginRequest(const FrameLoadRequest& frameLoadRequest, bool sendNotification, void* notifyData, bool shouldAllowPopups)
89             : m_frameLoadRequest(frameLoadRequest)
90             , m_notifyData(notifyData)
91             , m_sendNotification(sendNotification)
92             , m_shouldAllowPopups(shouldAllowPopups) { }
93     public:
94         const FrameLoadRequest& frameLoadRequest() const { return m_frameLoadRequest; }
95         void* notifyData() const { return m_notifyData; }
96         bool sendNotification() const { return m_sendNotification; }
97         bool shouldAllowPopups() const { return m_shouldAllowPopups; }
98     private:
99         FrameLoadRequest m_frameLoadRequest;
100         void* m_notifyData;
101         bool m_sendNotification;
102         bool m_shouldAllowPopups;
103     };
104
105     class PluginManualLoader {
106     public:
107         virtual ~PluginManualLoader() {}
108         virtual void didReceiveResponse(const ResourceResponse&) = 0;
109         virtual void didReceiveData(const char*, int) = 0;
110         virtual void didFinishLoading() = 0;
111         virtual void didFail(const ResourceError&) = 0;
112     };
113
114     class PluginView : public Widget, private PluginStreamClient, public PluginManualLoader, private HaltablePlugin, private MediaCanStartListener {
115     public:
116         static PassRefPtr<PluginView> create(Frame* parentFrame, const IntSize&, Element*, const KURL&, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually);
117         virtual ~PluginView();
118
119         PluginPackage* plugin() const { return m_plugin.get(); }
120         NPP instance() const { return m_instance; }
121
122         void setNPWindowRect(const IntRect&);
123         static PluginView* currentPluginView();
124
125         PassRefPtr<JSC::Bindings::Instance> bindingInstance();
126
127         PluginStatus status() const { return m_status; }
128
129         // NPN functions
130         NPError getURLNotify(const char* url, const char* target, void* notifyData);
131         NPError getURL(const char* url, const char* target);
132         NPError postURLNotify(const char* url, const char* target, uint32 len, const char* but, NPBool file, void* notifyData);
133         NPError postURL(const char* url, const char* target, uint32 len, const char* but, NPBool file);
134         NPError newStream(NPMIMEType type, const char* target, NPStream** stream);
135         int32 write(NPStream* stream, int32 len, void* buffer);
136         NPError destroyStream(NPStream* stream, NPReason reason);
137         const char* userAgent();
138 #if ENABLE(NETSCAPE_PLUGIN_API)
139         static const char* userAgentStatic();
140 #endif
141         void status(const char* message);
142         NPError getValue(NPNVariable variable, void* value);
143 #if ENABLE(NETSCAPE_PLUGIN_API)
144         static NPError getValueStatic(NPNVariable variable, void* value);
145 #endif
146         NPError setValue(NPPVariable variable, void* value);
147         void invalidateRect(NPRect*);
148         void invalidateRegion(NPRegion);
149         void forceRedraw();
150         void pushPopupsEnabledState(bool state);
151         void popPopupsEnabledState();
152
153         virtual void invalidateRect(const IntRect&);
154
155         bool arePopupsAllowed() const;
156
157         void setJavaScriptPaused(bool);
158
159         void privateBrowsingStateChanged(bool);
160
161         void disconnectStream(PluginStream*);
162         void streamDidFinishLoading(PluginStream* stream) { disconnectStream(stream); }
163
164         // Widget functions
165         virtual void setFrameRect(const IntRect&);
166         virtual void frameRectsChanged();
167         virtual void setFocus();
168         virtual void show();
169         virtual void hide();
170         virtual void paint(GraphicsContext*, const IntRect&);
171
172         // This method is used by plugins on all platforms to obtain a clip rect that includes clips set by WebCore,
173         // e.g., in overflow:auto sections.  The clip rects coordinates are in the containing window's coordinate space.
174         // This clip includes any clips that the widget itself sets up for its children.
175         IntRect windowClipRect() const;
176
177         virtual void handleEvent(Event*);
178         virtual void setParent(ScrollView*);
179         virtual void setParentVisible(bool);
180
181         virtual bool isPluginView() const { return true; }
182
183         Frame* parentFrame() const { return m_parentFrame.get(); }
184
185         void focusPluginElement();
186
187         const String& pluginsPage() const { return m_pluginsPage; }
188         const String& mimeType() const { return m_mimeType; }
189         const KURL& url() const { return m_url; }
190
191 #if OS(WINDOWS) && ENABLE(NETSCAPE_PLUGIN_API)
192         static LRESULT CALLBACK PluginViewWndProc(HWND, UINT, WPARAM, LPARAM);
193         LRESULT wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
194         WNDPROC pluginWndProc() const { return m_pluginWndProc; }
195 #endif
196
197         // Used for manual loading
198         void didReceiveResponse(const ResourceResponse&);
199         void didReceiveData(const char*, int);
200         void didFinishLoading();
201         void didFail(const ResourceError&);
202
203         // HaltablePlugin
204         virtual void halt();
205         virtual void restart();
206         virtual Node* node() const;
207         virtual bool isWindowed() const { return m_isWindowed; }
208         virtual String pluginName() const;
209
210         bool isHalted() const { return m_isHalted; }
211         bool hasBeenHalted() const { return m_hasBeenHalted; }
212
213         static bool isCallingPlugin();
214
215         bool start();
216
217 #if ENABLE(NETSCAPE_PLUGIN_API)
218         static void keepAlive(NPP);
219 #endif
220         void keepAlive();
221
222     private:
223         PluginView(Frame* parentFrame, const IntSize&, PluginPackage*, Element*, const KURL&, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually);
224
225         void setParameters(const Vector<String>& paramNames, const Vector<String>& paramValues);
226         bool startOrAddToUnstartedList();
227         void removeFromUnstartedListIfNecessary();
228         void init();
229         bool platformStart();
230         void stop();
231         void platformDestroy();
232         static void setCurrentPluginView(PluginView*);
233         NPError load(const FrameLoadRequest&, bool sendNotification, void* notifyData);
234         NPError handlePost(const char* url, const char* target, uint32 len, const char* buf, bool file, void* notifyData, bool sendNotification, bool allowHeaders);
235         NPError handlePostReadFile(Vector<char>& buffer, uint32 len, const char* buf);
236         static void freeStringArray(char** stringArray, int length);
237         void setCallingPlugin(bool) const;
238
239         void invalidateWindowlessPluginRect(const IntRect&);
240
241         virtual void mediaCanStart();
242
243 #if OS(WINDOWS) && ENABLE(NETSCAPE_PLUGIN_API)
244         void paintWindowedPluginIntoContext(GraphicsContext*, const IntRect&);
245         static HDC WINAPI hookedBeginPaint(HWND, PAINTSTRUCT*);
246         static BOOL WINAPI hookedEndPaint(HWND, const PAINTSTRUCT*);
247 #endif
248
249         static bool platformGetValueStatic(NPNVariable variable, void* value, NPError* result);
250         bool platformGetValue(NPNVariable variable, void* value, NPError* result);
251
252         RefPtr<Frame> m_parentFrame;
253         RefPtr<PluginPackage> m_plugin;
254         Element* m_element;
255         bool m_isStarted;
256         KURL m_url;
257         KURL m_baseURL;
258         PluginStatus m_status;
259         Vector<IntRect> m_invalidRects;
260
261         void performRequest(PluginRequest*);
262         void scheduleRequest(PluginRequest*);
263         void requestTimerFired(Timer<PluginView>*);
264         void invalidateTimerFired(Timer<PluginView>*);
265         Timer<PluginView> m_requestTimer;
266         Timer<PluginView> m_invalidateTimer;
267
268         void popPopupsStateTimerFired(Timer<PluginView>*);
269         Timer<PluginView> m_popPopupsStateTimer;
270
271         void lifeSupportTimerFired(Timer<PluginView>*);
272         Timer<PluginView> m_lifeSupportTimer;
273
274 #ifndef NP_NO_CARBON
275         bool dispatchNPEvent(NPEvent&);
276 #endif
277         void updatePluginWidget();
278         void paintMissingPluginIcon(GraphicsContext*, const IntRect&);
279
280         void handleKeyboardEvent(KeyboardEvent*);
281         void handleMouseEvent(MouseEvent*);
282 #if defined(XP_UNIX) && ENABLE(NETSCAPE_PLUGIN_API)
283         void handleFocusInEvent();
284         void handleFocusOutEvent();
285 #endif
286
287 #if OS(WINDOWS)
288         void paintIntoTransformedContext(HDC);
289         PassRefPtr<Image> snapshot();
290 #endif
291
292         int m_mode;
293         int m_paramCount;
294         char** m_paramNames;
295         char** m_paramValues;
296         String m_pluginsPage;
297
298         String m_mimeType;
299         CString m_userAgent;
300
301         NPP m_instance;
302         NPP_t m_instanceStruct;
303         NPWindow m_npWindow;
304
305         Vector<bool, 4> m_popupStateStack;
306
307         HashSet<RefPtr<PluginStream> > m_streams;
308         Vector<PluginRequest*> m_requests;
309
310         bool m_isWindowed;
311         bool m_isTransparent;
312         bool m_haveInitialized;
313         bool m_isWaitingToStart;
314
315 #if defined(XP_UNIX)
316         bool m_needsXEmbed;
317 #endif
318
319 #if OS(WINDOWS) && ENABLE(NETSCAPE_PLUGIN_API)
320         OwnPtr<PluginMessageThrottlerWin> m_messageThrottler;
321         WNDPROC m_pluginWndProc;
322         unsigned m_lastMessage;
323         bool m_isCallingPluginWndProc;
324         HDC m_wmPrintHDC;
325         bool m_haveUpdatedPluginWidget;
326 #endif
327
328 #if ((PLATFORM(QT) || PLATFORM(WX)) && OS(WINDOWS)) || defined(XP_MACOSX)
329         // On Mac OSX and Qt/Windows the plugin does not have its own native widget,
330         // but is using the containing window as its reference for positioning/painting.
331         PlatformPluginWidget m_window;
332 public:
333         PlatformPluginWidget platformPluginWidget() const { return m_window; }
334         void setPlatformPluginWidget(PlatformPluginWidget widget) { m_window = widget; }
335 #else
336 public:
337         void setPlatformPluginWidget(PlatformPluginWidget widget) { setPlatformWidget(widget); }
338         PlatformPluginWidget platformPluginWidget() const { return platformWidget(); }
339 #endif
340
341 private:
342
343 #if defined(XP_UNIX) || OS(SYMBIAN)
344         void setNPWindowIfNeeded();
345 #elif defined(XP_MACOSX)
346         NP_CGContext m_npCgContext;
347         OwnPtr<Timer<PluginView> > m_nullEventTimer;
348         NPDrawingModel m_drawingModel;
349         NPEventModel m_eventModel;
350         CGContextRef m_contextRef;
351         WindowRef m_fakeWindow;
352 #if PLATFORM(QT)
353         QPixmap m_pixmap;
354 #endif
355
356         Point m_lastMousePos;
357         void setNPWindowIfNeeded();
358         void nullEventTimerFired(Timer<PluginView>*);
359         Point globalMousePosForPlugin() const;
360         Point mousePosForPlugin(MouseEvent* event = 0) const;
361 #endif
362
363 #if defined(XP_UNIX) && ENABLE(NETSCAPE_PLUGIN_API)
364         bool m_hasPendingGeometryChange;
365         Pixmap m_drawable;
366         Visual* m_visual;
367         Colormap m_colormap;
368         Display* m_pluginDisplay;
369
370         void initXEvent(XEvent* event);
371 #endif
372
373         IntRect m_clipRect; // The clip rect to apply to a windowed plug-in
374         IntRect m_windowRect; // Our window rect.
375
376         bool m_loadManually;
377         RefPtr<PluginStream> m_manualStream;
378
379         bool m_isJavaScriptPaused;
380
381         bool m_isHalted;
382         bool m_hasBeenHalted;
383
384         static PluginView* s_currentPluginView;
385     };
386
387 } // namespace WebCore
388
389 #endif