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