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