2008-05-14 Julien Chaffraix <jchaffraix@webkit.org>
[WebKit-https.git] / WebCore / plugins / PluginView.h
1 /*
2  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
3  * Copyright (C) 2008 Collabora Ltd. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #ifndef PluginView_H
28 #define PluginView_H
29
30 #include "CString.h"
31 #include "FrameLoadRequest.h"
32 #include "IntRect.h"
33 #include "KURL.h"
34 #include "PlatformString.h"
35 #include "PluginStream.h"
36 #include "ResourceRequest.h"
37 #include "Timer.h"
38 #include "Widget.h"
39 #include "npruntime_internal.h"
40 #include <wtf/HashMap.h>
41 #include <wtf/HashSet.h>
42 #include <wtf/OwnPtr.h>
43 #include <wtf/PassRefPtr.h>
44 #include <wtf/RefPtr.h>
45 #include <wtf/Vector.h>
46
47 namespace KJS {
48     namespace Bindings {
49         class Instance;
50     }
51 }
52
53 namespace WebCore {
54     class Element;
55     class Frame;
56     class KeyboardEvent;
57     class MouseEvent;
58     class KURL;
59 #if PLATFORM(WIN)
60     class PluginMessageThrottlerWin;
61 #endif
62     class PluginPackage;
63     class PluginRequest;
64     class PluginStream;
65     class ResourceError;
66     class ResourceResponse;
67
68     enum PluginStatus {
69         PluginStatusCanNotFindPlugin,
70         PluginStatusCanNotLoadPlugin,
71         PluginStatusLoadedSuccessfully
72     };
73
74     class PluginRequest {
75     public:
76         PluginRequest(const FrameLoadRequest& frameLoadRequest, bool sendNotification, void* notifyData, bool shouldAllowPopups)
77             : m_frameLoadRequest(frameLoadRequest)
78             , m_notifyData(notifyData)
79             , m_sendNotification(sendNotification)
80             , m_shouldAllowPopups(shouldAllowPopups) { }
81     public:
82         const FrameLoadRequest& frameLoadRequest() const { return m_frameLoadRequest; }
83         void* notifyData() const { return m_notifyData; }
84         bool sendNotification() const { return m_sendNotification; }
85         bool shouldAllowPopups() const { return m_shouldAllowPopups; }
86     private:
87         FrameLoadRequest m_frameLoadRequest;
88         void* m_notifyData;
89         bool m_sendNotification;
90         bool m_shouldAllowPopups;
91     };
92
93     class PluginView : public Widget, private PluginStreamClient {
94 #if PLATFORM(WIN)
95     friend static LRESULT CALLBACK PluginViewWndProc(HWND, UINT, WPARAM, LPARAM);
96 #endif
97
98     public:
99         static PluginView* create(Frame* parentFrame, const IntSize&, Element*, const KURL&, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually);
100         virtual ~PluginView();
101
102         PluginPackage* plugin() const { return m_plugin.get(); }
103         NPP instance() const { return m_instance; }
104
105         void setNPWindowRect(const IntRect&);
106         static PluginView* currentPluginView();
107
108         PassRefPtr<KJS::Bindings::Instance> bindingInstance();
109
110         PluginStatus status() const { return m_status; }
111
112         // NPN functions
113         NPError getURLNotify(const char* url, const char* target, void* notifyData);
114         NPError getURL(const char* url, const char* target);
115         NPError postURLNotify(const char* url, const char* target, uint32 len, const char* but, NPBool file, void* notifyData);
116         NPError postURL(const char* url, const char* target, uint32 len, const char* but, NPBool file);
117         NPError newStream(NPMIMEType type, const char* target, NPStream** stream);
118         int32 write(NPStream* stream, int32 len, void* buffer);
119         NPError destroyStream(NPStream* stream, NPReason reason);
120         const char* userAgent();
121         void status(const char* message);
122         NPError getValue(NPNVariable variable, void* value);
123         NPError setValue(NPPVariable variable, void* value);
124         void invalidateRect(NPRect*);
125         void invalidateRegion(NPRegion);
126         void forceRedraw();
127         void pushPopupsEnabledState(bool state);
128         void popPopupsEnabledState();
129
130         bool arePopupsAllowed() const;
131
132         void setJavaScriptPaused(bool);
133
134         void disconnectStream(PluginStream*);
135         void streamDidFinishLoading(PluginStream* stream) { disconnectStream(stream); }
136
137         // Widget functions
138         virtual void setFrameGeometry(const IntRect&);
139         virtual void geometryChanged() const;
140         virtual void setFocus();
141         virtual void show();
142         virtual void hide();
143         virtual void paint(GraphicsContext*, const IntRect&);
144         virtual IntRect windowClipRect() const;
145         virtual void handleEvent(Event*);
146         virtual void setParent(ScrollView*);
147
148         virtual void attachToWindow();
149         virtual void detachFromWindow();
150
151         virtual bool isPluginView() const { return true; }
152
153 #if PLATFORM(WIN)
154         LRESULT wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
155         WNDPROC pluginWndProc() const { return m_pluginWndProc; }
156 #endif
157
158         // Used for manual loading
159         void didReceiveResponse(const ResourceResponse&);
160         void didReceiveData(const char*, int);
161         void didFinishLoading();
162         void didFail(const ResourceError&);
163
164         static bool isCallingPlugin();
165
166     private:
167         PluginView(Frame* parentFrame, const IntSize&, PluginPackage*, Element*, const KURL&, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually);
168
169         void setParameters(const Vector<String>& paramNames, const Vector<String>& paramValues);
170         void init();
171         bool start();
172         void stop();
173         static void setCurrentPluginView(PluginView*);
174         NPError load(const FrameLoadRequest&, bool sendNotification, void* notifyData);
175         NPError handlePost(const char* url, const char* target, uint32 len, const char* buf, bool file, void* notifyData, bool sendNotification, bool allowHeaders);
176         NPError handlePostReadFile(Vector<char>& buffer, uint32 len, const char* buf);
177         static void freeStringArray(char** stringArray, int length);
178         void setCallingPlugin(bool) const;
179
180         Frame* m_parentFrame;
181         RefPtr<PluginPackage> m_plugin;
182         Element* m_element;
183         bool m_isStarted;
184         KURL m_url;
185         KURL m_baseURL;
186         PluginStatus m_status;
187         Vector<IntRect> m_invalidRects;
188
189         void performRequest(PluginRequest*);
190         void scheduleRequest(PluginRequest*);
191         void requestTimerFired(Timer<PluginView>*);
192         void invalidateTimerFired(Timer<PluginView>*);
193         Timer<PluginView> m_requestTimer;
194         Timer<PluginView> m_invalidateTimer;
195
196         void popPopupsStateTimerFired(Timer<PluginView>*);
197         Timer<PluginView> m_popPopupsStateTimer;
198
199         bool dispatchNPEvent(NPEvent&);
200         void updateWindow() const;
201         void paintMissingPluginIcon(GraphicsContext*, const IntRect&);
202
203         void handleKeyboardEvent(KeyboardEvent*);
204         void handleMouseEvent(MouseEvent*);
205
206         int m_mode;
207         int m_paramCount;
208         char** m_paramNames;
209         char** m_paramValues;
210
211         CString m_mimeType;
212         CString m_userAgent;
213         
214         NPP m_instance;
215         NPP_t m_instanceStruct;
216         NPWindow m_npWindow;
217
218         Vector<bool, 4> m_popupStateStack;
219
220         HashSet<RefPtr<PluginStream> > m_streams;
221         Vector<PluginRequest*> m_requests;
222
223         bool m_isWindowed;
224         bool m_isTransparent;
225         bool m_isVisible;
226         bool m_attachedToWindow;
227         bool m_haveInitialized;
228
229 #if PLATFORM(GTK) || defined(Q_WS_X11)
230         bool m_needsXEmbed;
231 #endif
232
233 #if PLATFORM(WIN)
234         OwnPtr<PluginMessageThrottlerWin> m_messageThrottler;
235         WNDPROC m_pluginWndProc;
236         unsigned m_lastMessage;
237         bool m_isCallingPluginWndProc;
238 #endif
239
240         PlatformWidget m_window; // for windowed plug-ins
241         mutable IntRect m_clipRect; // The clip rect to apply to a windowed plug-in
242         mutable IntRect m_windowRect; // Our window rect.
243
244         bool m_loadManually;
245         RefPtr<PluginStream> m_manualStream;
246
247         bool m_isJavaScriptPaused;
248
249         static PluginView* s_currentPluginView;
250     };
251
252 } // namespace WebCore
253
254 #endif