Fix <rdar://5517707> Crash on wptv.wp.pl when "make bigger" button is clicked
[WebKit-https.git] / WebCore / plugins / win / PluginViewWin.cpp
1 /*
2  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "PluginViewWin.h"
28
29 #include "Document.h"
30 #include "DocumentLoader.h"
31 #include "Element.h"
32 #include "EventNames.h"
33 #include "FrameLoader.h"
34 #include "FrameLoadRequest.h"
35 #include "FrameTree.h"
36 #include "Frame.h"
37 #include "FrameView.h"
38 #include "GraphicsContext.h"
39 #include "Image.h"
40 #include "HTMLNames.h"
41 #include "HTMLPlugInElement.h"
42 #include "KeyboardEvent.h"
43 #include "MIMETypeRegistry.h"
44 #include "MouseEvent.h"
45 #include "NotImplemented.h"
46 #include "Page.h"
47 #include "FocusController.h"
48 #include "PlatformMouseEvent.h"
49 #include "PluginPackageWin.h"
50 #include "kjs_binding.h"
51 #include "kjs_proxy.h"
52 #include "kjs_window.h"
53 #include "PluginDebug.h"
54 #include "PluginPackageWin.h"
55 #include "PluginStreamWin.h"
56 #include "npruntime_impl.h"
57 #include "runtime_root.h"
58 #include "Settings.h"
59 #include <kjs/JSLock.h>
60 #include <kjs/value.h>
61 #include <wtf/ASCIICType.h>
62
63 using KJS::ExecState;
64 using KJS::JSLock;
65 using KJS::JSObject;
66 using KJS::JSValue;
67 using KJS::UString;
68 using KJS::Window;
69
70 using std::min;
71
72 using namespace WTF;
73
74 namespace WebCore {
75
76 using namespace EventNames;
77 using namespace HTMLNames;
78
79 class PluginRequestWin {
80 public:
81     PluginRequestWin(const FrameLoadRequest& frameLoadRequest, bool sendNotification, void* notifyData, bool shouldAllowPopups)
82         : m_frameLoadRequest(frameLoadRequest)
83         , m_notifyData(notifyData)
84         , m_sendNotification(sendNotification)
85         , m_shouldAllowPopups(shouldAllowPopups) { }
86 public:
87     const FrameLoadRequest& frameLoadRequest() const { return m_frameLoadRequest; }
88     void* notifyData() const { return m_notifyData; }
89     bool sendNotification() const { return m_sendNotification; }
90     bool shouldAllowPopups() const { return m_shouldAllowPopups; }
91 private:
92     FrameLoadRequest m_frameLoadRequest;
93     void* m_notifyData;
94     bool m_sendNotification;
95     bool m_shouldAllowPopups;
96 };
97
98 static const double MessageThrottleTimeInterval = 0.001;
99 static int s_callingPlugin;
100
101 class PluginMessageThrottlerWin {
102 public:
103     PluginMessageThrottlerWin(PluginViewWin* pluginView)
104         : m_back(0), m_front(0)
105         , m_pluginView(pluginView)
106         , m_messageThrottleTimer(this, &PluginMessageThrottlerWin::messageThrottleTimerFired)
107     {
108         // Initialize the free list with our inline messages
109         for (unsigned i = 0; i < NumInlineMessages - 1; i++)
110             m_inlineMessages[i].next = &m_inlineMessages[i + 1];
111         m_inlineMessages[NumInlineMessages - 1].next = 0;
112         m_freeInlineMessages = &m_inlineMessages[0];
113     }
114
115     ~PluginMessageThrottlerWin()
116     {
117         PluginMessage* next;
118     
119         for (PluginMessage* message = m_front; message; message = next) {
120             next = message->next;
121             freeMessage(message);
122         }        
123     }
124     
125     void appendMessage(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) 
126     {
127         PluginMessage* message = allocateMessage();
128
129         message->hWnd = hWnd;
130         message->msg = msg;
131         message->wParam = wParam;
132         message->lParam = lParam;
133         message->next = 0;
134
135         if (m_back)
136             m_back->next = message;
137         m_back = message;
138         if (!m_front)
139             m_front = message;
140
141         if (!m_messageThrottleTimer.isActive())
142             m_messageThrottleTimer.startOneShot(MessageThrottleTimeInterval);
143     }
144
145 private:
146     struct PluginMessage {
147         HWND hWnd;
148         UINT msg;
149         WPARAM wParam;
150         LPARAM lParam;
151
152         struct PluginMessage* next;
153     };
154     
155     void messageThrottleTimerFired(Timer<PluginMessageThrottlerWin>*)
156     {
157         PluginMessage* message = m_front;
158         m_front = m_front->next;
159         if (message == m_back)
160             m_back = 0;
161
162         ::CallWindowProc(m_pluginView->pluginWndProc(), message->hWnd, message->msg, message->wParam, message->lParam);
163
164         freeMessage(message);
165
166         if (m_front)
167             m_messageThrottleTimer.startOneShot(MessageThrottleTimeInterval);
168     }
169
170     PluginMessage* allocateMessage()
171     {
172         PluginMessage *message;
173
174         if (m_freeInlineMessages) {
175             message = m_freeInlineMessages;
176             m_freeInlineMessages = message->next;
177         } else
178             message = new PluginMessage;
179
180         return message;
181     }
182
183     bool isInlineMessage(PluginMessage* message) 
184     {
185         return message >= &m_inlineMessages[0] && message <= &m_inlineMessages[NumInlineMessages - 1];
186     }
187
188     void freeMessage(PluginMessage* message) 
189     {
190         if (isInlineMessage(message)) {
191             message->next = m_freeInlineMessages;
192             m_freeInlineMessages = message;
193         } else
194             delete message;
195     }
196
197     PluginViewWin* m_pluginView;
198     PluginMessage* m_back;
199     PluginMessage* m_front;
200
201     static const int NumInlineMessages = 4;
202     PluginMessage m_inlineMessages[NumInlineMessages];
203     PluginMessage* m_freeInlineMessages;
204
205     Timer<PluginMessageThrottlerWin> m_messageThrottleTimer;
206 };
207
208 static String scriptStringIfJavaScriptURL(const KURL& url)
209 {
210     if (!url.string().startsWith("javascript:", false))
211         return String();
212
213     // This returns an unescaped string
214     return KURL::decode_string(url.deprecatedString().mid(11));
215 }
216
217 PluginViewWin* PluginViewWin::s_currentPluginView = 0;
218
219 const LPCWSTR kWebPluginViewWindowClassName = L"WebPluginView";
220 const LPCWSTR kWebPluginViewProperty = L"WebPluginViewProperty";
221
222 static const char* MozillaUserAgent = "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1) Gecko/20061010 Firefox/2.0";
223
224 static LRESULT CALLBACK PluginViewWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
225
226 static bool registerPluginView()
227 {
228     static bool haveRegisteredWindowClass = false;
229     if (haveRegisteredWindowClass)
230         return true;
231
232     haveRegisteredWindowClass = true;
233
234     ASSERT(Page::instanceHandle());
235
236     WNDCLASSEX wcex;
237
238     wcex.cbSize = sizeof(WNDCLASSEX);
239
240     wcex.style          = CS_DBLCLKS;
241     wcex.lpfnWndProc    = DefWindowProc;
242     wcex.cbClsExtra     = 0;
243     wcex.cbWndExtra     = 0;
244     wcex.hInstance      = Page::instanceHandle();
245     wcex.hIcon          = 0;
246     wcex.hCursor        = LoadCursor(0, IDC_ARROW);
247     wcex.hbrBackground  = (HBRUSH)COLOR_WINDOW;
248     wcex.lpszMenuName   = 0;
249     wcex.lpszClassName  = kWebPluginViewWindowClassName;
250     wcex.hIconSm        = 0;
251
252     return !!RegisterClassEx(&wcex);
253 }
254
255 static LRESULT CALLBACK PluginViewWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
256 {
257     PluginViewWin* pluginView = reinterpret_cast<PluginViewWin*>(GetProp(hWnd, kWebPluginViewProperty));
258
259     return pluginView->wndProc(hWnd, message, wParam, lParam);
260 }
261
262 void PluginViewWin::popPopupsStateTimerFired(Timer<PluginViewWin>*)
263 {
264     popPopupsEnabledState();
265 }
266
267
268 static bool isWindowsMessageUserGesture(UINT message)
269 {
270     switch (message) {
271         case WM_LBUTTONUP:
272         case WM_MBUTTONUP:
273         case WM_RBUTTONUP:
274         case WM_KEYUP:
275             return true;
276         default:
277             return false;
278     }
279 }
280
281 LRESULT
282 PluginViewWin::wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
283 {
284     if (message == m_lastMessage &&
285         (m_quirks & PluginQuirkDontCallWndProcForSameMessageRecursively) && 
286         m_isCallingPluginWndProc)
287         return 1;
288
289     if (message == WM_USER + 1 &&
290         (m_quirks & PluginQuirkThrottleWMUserPlusOneMessages)) {
291         if (!m_messageThrottler)
292             m_messageThrottler.set(new PluginMessageThrottlerWin(this));
293
294         m_messageThrottler->appendMessage(hWnd, message, wParam, lParam);
295         return 0;
296     }
297
298     m_lastMessage = message;
299     m_isCallingPluginWndProc = true;
300
301     // If the plug-in doesn't explicitly support changing the pop-up state, we enable
302     // popups for all user gestures.
303     // Note that we need to pop the state in a timer, because the Flash plug-in 
304     // pops up windows in response to a posted message.
305     if (m_plugin->pluginFuncs()->version < NPVERS_HAS_POPUPS_ENABLED_STATE &&
306         isWindowsMessageUserGesture(message) && !m_popPopupsStateTimer.isActive()) {
307         
308         pushPopupsEnabledState(true);
309
310         m_popPopupsStateTimer.startOneShot(0);
311     }
312
313     // Call the plug-in's window proc.
314     LRESULT result = ::CallWindowProc(m_pluginWndProc, hWnd, message, wParam, lParam);
315
316     m_isCallingPluginWndProc = false;
317
318     return result;
319 }
320
321 void PluginViewWin::updateWindow() const
322 {
323     if (!parent())
324         return;
325
326     ASSERT(parent()->isFrameView());
327     FrameView* frameView = static_cast<FrameView*>(parent());
328
329     IntRect oldWindowRect = m_windowRect;
330     IntRect oldClipRect = m_clipRect;
331
332     m_windowRect = IntRect(frameView->contentsToWindow(frameGeometry().location()), frameGeometry().size());
333     m_clipRect = windowClipRect();
334     m_clipRect.move(-m_windowRect.x(), -m_windowRect.y());
335
336     if (m_window && (m_windowRect != oldWindowRect || m_clipRect != oldClipRect)) {
337         HRGN rgn;
338
339         // To prevent flashes while scrolling, we disable drawing during the window
340         // update process by clipping the window to the zero rect.
341
342         // FIXME: Setting the window region to an empty region causes bad scrolling 
343         // repaint problems with at least the WMP and Java plugins.
344         // <rdar://problem/5211187> Come up with a better way of handling plug-in scrolling
345         // is the bug that tracks the work of fixing this.
346         //rgn = ::CreateRectRgn(0, 0, 0, 0);
347         //::SetWindowRgn(m_window, rgn, false);
348
349         setCallingPlugin(true);
350         if (m_windowRect != oldWindowRect)
351             ::MoveWindow(m_window, m_windowRect.x(), m_windowRect.y(), m_windowRect.width(), m_windowRect.height(), true);
352
353         // Re-enable drawing. (This serves the double purpose of updating the clip rect if it has changed.)
354         rgn = ::CreateRectRgn(m_clipRect.x(), m_clipRect.y(), m_clipRect.right(), m_clipRect.bottom());
355         ::SetWindowRgn(m_window, rgn, true);
356         ::UpdateWindow(m_window);
357         setCallingPlugin(false);
358     }
359 }
360
361 IntRect PluginViewWin::windowClipRect() const
362 {
363     // Start by clipping to our bounds.
364     IntRect clipRect(m_windowRect);
365     
366     // Take our element and get the clip rect from the enclosing layer and frame view.
367     RenderLayer* layer = m_element->renderer()->enclosingLayer();
368     FrameView* parentView = m_element->document()->view();
369     clipRect.intersect(parentView->windowClipRectForLayer(layer, true));
370
371     return clipRect;
372 }
373
374 void PluginViewWin::setFrameGeometry(const IntRect& rect)
375 {
376     if (m_element->document()->printing())
377         return;
378
379     if (rect != frameGeometry())
380         Widget::setFrameGeometry(rect);
381
382     updateWindow();
383     setNPWindowRect(rect);
384 }
385
386 void PluginViewWin::geometryChanged() const
387 {
388     updateWindow();
389 }
390
391 void PluginViewWin::setFocus()
392 {
393     if (m_window)
394         SetFocus(m_window);
395
396     Widget::setFocus();
397 }
398
399 void PluginViewWin::show()
400 {
401     m_isVisible = true;
402
403     if (m_attachedToWindow && m_window)
404         ShowWindow(m_window, SW_SHOWNA);
405
406     Widget::show();
407 }
408
409 void PluginViewWin::hide()
410 {
411     m_isVisible = false;
412
413     if (m_attachedToWindow && m_window)
414         ShowWindow(m_window, SW_HIDE);
415
416     Widget::hide();
417 }
418
419 void PluginViewWin::paintMissingPluginIcon(GraphicsContext* context, const IntRect& rect)
420 {
421     static Image* nullPluginImage;
422     if (!nullPluginImage)
423         nullPluginImage = Image::loadPlatformResource("nullPlugin");
424
425     IntRect imageRect(frameGeometry().x(), frameGeometry().y(), nullPluginImage->width(), nullPluginImage->height());
426
427     int xOffset = (frameGeometry().width() - imageRect.width()) / 2;
428     int yOffset = (frameGeometry().height() - imageRect.height()) / 2;
429
430     imageRect.move(xOffset, yOffset);
431
432     if (!rect.intersects(imageRect))
433         return;
434
435     context->save();
436     context->clip(windowClipRect());
437     context->drawImage(nullPluginImage, imageRect.location());
438     context->restore();
439 }
440
441 bool PluginViewWin::dispatchNPEvent(NPEvent* npEvent)
442 {
443     if (!m_plugin->pluginFuncs()->event)
444         return true;
445
446     bool shouldPop = false;
447
448     if (m_plugin->pluginFuncs()->version < NPVERS_HAS_POPUPS_ENABLED_STATE && isWindowsMessageUserGesture(npEvent->event)) {
449         pushPopupsEnabledState(true);
450         shouldPop = true;
451     }
452
453     KJS::JSLock::DropAllLocks dropAllLocks;
454     setCallingPlugin(true);
455     bool result = m_plugin->pluginFuncs()->event(m_instance, &npEvent);
456     setCallingPlugin(false);
457
458     if (shouldPop) 
459         popPopupsEnabledState();
460
461     return result;
462 }
463
464 void PluginViewWin::paint(GraphicsContext* context, const IntRect& rect)
465 {
466     if (!m_isStarted) {
467         // Draw the "missing plugin" image
468         paintMissingPluginIcon(context, rect);
469         return;
470     }
471
472     if (m_isWindowed || context->paintingDisabled())
473         return;
474
475     HDC hdc = context->getWindowsContext();
476
477     // The plugin expects that the passed in DC has window coordinates.
478     // (This probably breaks funky SVG transform stuff)
479     XFORM transform;
480     GetWorldTransform(hdc, &transform);
481     transform.eDx = 0;
482     transform.eDy = 0;
483     SetWorldTransform(hdc, &transform);
484
485     NPEvent npEvent;
486
487     m_npWindow.type = NPWindowTypeDrawable;
488     m_npWindow.window = hdc;
489
490     ASSERT(parent()->isFrameView());
491     IntPoint p = static_cast<FrameView*>(parent())->contentsToWindow(frameGeometry().location());
492     
493     WINDOWPOS windowpos;
494     memset(&windowpos, 0, sizeof(windowpos));
495
496     windowpos.x = p.x();
497     windowpos.y = p.y();
498     windowpos.cx = frameGeometry().width();
499     windowpos.cy = frameGeometry().height();
500
501     npEvent.event = WM_WINDOWPOSCHANGED;
502     npEvent.lParam = reinterpret_cast<uint32>(&windowpos);
503     npEvent.wParam = 0;
504
505     dispatchNPEvent(&npEvent);
506
507     setNPWindowRect(frameGeometry());
508
509     npEvent.event = WM_PAINT;
510     npEvent.wParam = reinterpret_cast<uint32>(hdc);
511
512     // This is supposed to be a pointer to the dirty rect, but it seems that the Flash plugin
513     // ignores it so we just pass null.
514     npEvent.lParam = 0;
515
516     dispatchNPEvent(&npEvent);
517
518     context->releaseWindowsContext(hdc);
519 }
520
521 void PluginViewWin::handleKeyboardEvent(KeyboardEvent* event)
522 {
523     NPEvent npEvent;
524
525     npEvent.wParam = event->keyCode();    
526
527     if (event->type() == keydownEvent) {
528         npEvent.event = WM_KEYDOWN;
529         npEvent.lParam = 0;
530     } else if (event->type() == keyupEvent) {
531         npEvent.event = WM_KEYUP;
532         npEvent.lParam = 0x8000;
533     }
534
535     KJS::JSLock::DropAllLocks;
536     if (!dispatchNPEvent(&npEvent))
537         event->setDefaultHandled();
538 }
539
540 extern HCURSOR lastSetCursor;
541 extern bool ignoreNextSetCursor;
542
543 void PluginViewWin::handleMouseEvent(MouseEvent* event)
544 {
545     NPEvent npEvent;
546
547     IntPoint p = static_cast<FrameView*>(parent())->contentsToWindow(IntPoint(event->pageX(), event->pageY()));
548
549     npEvent.lParam = MAKELPARAM(p.x(), p.y());
550     npEvent.wParam = 0;
551
552     if (event->ctrlKey())
553         npEvent.wParam |= MK_CONTROL;
554     if (event->shiftKey())
555         npEvent.wParam |= MK_SHIFT;
556
557     if (event->type() == mousemoveEvent ||
558         event->type() == mouseoutEvent || 
559         event->type() == mouseoverEvent) {
560         npEvent.event = WM_MOUSEMOVE;
561         if (event->buttonDown())
562             switch (event->button()) {
563                 case LeftButton:
564                     npEvent.wParam |= MK_LBUTTON;
565                     break;
566                 case MiddleButton:
567                     npEvent.wParam |= MK_MBUTTON;
568                     break;
569                 case RightButton:
570                     npEvent.wParam |= MK_RBUTTON;
571                 break;
572             }
573     }
574     else if (event->type() == mousedownEvent) {
575         // Focus the plugin
576         if (Page* page = m_parentFrame->page())
577             page->focusController()->setFocusedFrame(m_parentFrame);
578         m_parentFrame->document()->setFocusedNode(m_element);
579         switch (event->button()) {
580             case 0:
581                 npEvent.event = WM_LBUTTONDOWN;
582                 break;
583             case 1:
584                 npEvent.event = WM_MBUTTONDOWN;
585                 break;
586             case 2:
587                 npEvent.event = WM_RBUTTONDOWN;
588                 break;
589         }
590     } else if (event->type() == mouseupEvent) {
591         switch (event->button()) {
592             case 0:
593                 npEvent.event = WM_LBUTTONUP;
594                 break;
595             case 1:
596                 npEvent.event = WM_MBUTTONUP;
597                 break;
598             case 2:
599                 npEvent.event = WM_RBUTTONUP;
600                 break;
601         }
602     } else
603         return;
604
605     HCURSOR currentCursor = ::GetCursor();
606
607     KJS::JSLock::DropAllLocks;
608     if (!dispatchNPEvent(&npEvent))
609         event->setDefaultHandled();
610
611     // Currently, Widget::setCursor is always called after this function in EventHandler.cpp
612     // and since we don't want that we set ignoreNextSetCursor to true here to prevent that.
613     ignoreNextSetCursor = true;     
614     lastSetCursor = ::GetCursor();
615 }
616
617 void PluginViewWin::handleEvent(Event* event)
618 {
619     if (!m_plugin || m_isWindowed)
620         return;
621
622     if (event->isMouseEvent())
623         handleMouseEvent(static_cast<MouseEvent*>(event));
624     else if (event->isKeyboardEvent())
625         handleKeyboardEvent(static_cast<KeyboardEvent*>(event));
626 }
627
628 void PluginViewWin::setParent(ScrollView* parent)
629 {
630     Widget::setParent(parent);
631
632     if (parent)
633         init();
634     else {
635         if (!m_window)
636             return;
637
638         // If the plug-in window or one of its children have the focus, we need to 
639         // clear it to prevent the web view window from being focused because that can
640         // trigger a layout while the plugin element is being detached.
641         HWND focusedWindow = ::GetFocus();
642         if (m_window == focusedWindow || ::IsChild(m_window, focusedWindow))
643             ::SetFocus(0);
644     }
645
646 }
647
648 void PluginViewWin::attachToWindow()
649 {
650     if (m_attachedToWindow)
651         return;
652
653     m_attachedToWindow = true;
654     if (m_isVisible && m_window)
655         ShowWindow(m_window, SW_SHOWNA);
656 }
657
658 void PluginViewWin::detachFromWindow()
659 {
660     if (!m_attachedToWindow)
661         return;
662
663     if (m_isVisible && m_window)
664         ShowWindow(m_window, SW_HIDE);
665     m_attachedToWindow = false;
666 }
667
668 void PluginViewWin::setNPWindowRect(const IntRect& rect)
669 {
670     if (!m_isStarted)
671         return;
672
673     IntPoint p = static_cast<FrameView*>(parent())->contentsToWindow(rect.location());
674     m_npWindow.x = p.x();
675     m_npWindow.y = p.y();
676
677     m_npWindow.width = rect.width();
678     m_npWindow.height = rect.height();
679
680     m_npWindow.clipRect.left = 0;
681     m_npWindow.clipRect.top = 0;
682     m_npWindow.clipRect.right = rect.width();
683     m_npWindow.clipRect.bottom = rect.height();
684
685     if (m_plugin->pluginFuncs()->setwindow) {
686         KJS::JSLock::DropAllLocks dropAllLocks;
687         setCallingPlugin(true);
688         m_plugin->pluginFuncs()->setwindow(m_instance, &m_npWindow);
689         setCallingPlugin(false);
690
691         if (!m_isWindowed)
692             return;
693
694         ASSERT(m_window);
695
696         WNDPROC currentWndProc = (WNDPROC)GetWindowLongPtr(m_window, GWLP_WNDPROC);
697         if (currentWndProc != PluginViewWndProc)
698             m_pluginWndProc = (WNDPROC)SetWindowLongPtr(m_window, GWLP_WNDPROC, (LONG)PluginViewWndProc);
699     }
700 }
701
702 bool PluginViewWin::start()
703 {
704     if (m_isStarted)
705         return false;
706
707     ASSERT(m_plugin);
708     ASSERT(m_plugin->pluginFuncs()->newp);
709
710     NPError npErr;
711     PluginViewWin::setCurrentPluginView(this);
712     {
713         KJS::JSLock::DropAllLocks dropAllLocks;
714         setCallingPlugin(true);
715         npErr = m_plugin->pluginFuncs()->newp((NPMIMEType)m_mimeType.data(), m_instance, m_mode, m_paramCount, m_paramNames, m_paramValues, NULL);
716         setCallingPlugin(false);
717         LOG_NPERROR(npErr);
718     }
719     PluginViewWin::setCurrentPluginView(0);
720
721     if (npErr != NPERR_NO_ERROR)
722         return false;
723
724     m_isStarted = true;
725
726     if (!m_url.isEmpty() && !m_loadManually) {
727         FrameLoadRequest frameLoadRequest;
728         frameLoadRequest.resourceRequest().setHTTPMethod("GET");
729         frameLoadRequest.resourceRequest().setURL(m_url);
730         load(frameLoadRequest, false, 0);
731     }
732
733     return true;
734 }
735
736 void PluginViewWin::stop()
737 {
738     if (!m_isStarted)
739         return;
740
741     HashSet<RefPtr<PluginStreamWin> > streams = m_streams;
742     HashSet<RefPtr<PluginStreamWin> >::iterator end = streams.end();
743     for (HashSet<RefPtr<PluginStreamWin> >::iterator it = streams.begin(); it != end; ++it) {
744         (*it)->stop();
745         disconnectStream((*it).get());
746     }
747
748     ASSERT(m_streams.isEmpty());
749
750     m_isStarted = false;
751
752     // Unsubclass the window
753     if (m_isWindowed) {
754         WNDPROC currentWndProc = (WNDPROC)GetWindowLongPtr(m_window, GWLP_WNDPROC);
755         
756         if (currentWndProc == PluginViewWndProc)
757             SetWindowLongPtr(m_window, GWLP_WNDPROC, (LONG)m_pluginWndProc);
758     }
759
760     KJS::JSLock::DropAllLocks;
761
762     // Clear the window
763     m_npWindow.window = 0;
764     if (m_plugin->pluginFuncs()->setwindow) {
765         setCallingPlugin(true);
766         m_plugin->pluginFuncs()->setwindow(m_instance, &m_npWindow);
767         setCallingPlugin(false);
768     }
769
770     // Destroy the plugin
771     NPSavedData* savedData = 0;
772     setCallingPlugin(true);
773     NPError npErr = m_plugin->pluginFuncs()->destroy(m_instance, &savedData);
774     setCallingPlugin(false);
775     LOG_NPERROR(npErr);
776
777     if (savedData) {
778         if (savedData->buf)
779             NPN_MemFree(savedData->buf);
780         NPN_MemFree(savedData);
781     }
782
783     m_instance->pdata = 0;
784 }
785
786 void PluginViewWin::setCurrentPluginView(PluginViewWin* pluginView)
787 {
788     s_currentPluginView = pluginView;
789 }
790
791 PluginViewWin* PluginViewWin::currentPluginView()
792 {
793     return s_currentPluginView;
794 }
795
796 static char* createUTF8String(const String& str)
797 {
798     CString cstr = str.utf8();
799     char* result = reinterpret_cast<char*>(fastMalloc(cstr.length() + 1));
800
801     strncpy(result, cstr.data(), cstr.length() + 1);
802
803     return result;
804 }
805
806 static void freeStringArray(char** stringArray, int length)
807 {
808     if (!stringArray)
809         return;
810
811     for (int i = 0; i < length; i++)
812         fastFree(stringArray[i]);
813
814     fastFree(stringArray);
815 }
816
817 static bool getString(KJSProxy* proxy, JSValue* result, String& string)
818 {
819     if (!proxy || !result || result->isUndefined())
820         return false;
821     JSLock lock;
822
823     ExecState* exec = proxy->globalObject()->globalExec();
824     UString ustring = result->toString(exec);
825     exec->clearException();
826
827     string = ustring;
828     return true;
829 }
830
831 void PluginViewWin::performRequest(PluginRequestWin* request)
832 {
833     KURL requestURL = request->frameLoadRequest().resourceRequest().url();
834     String jsString = scriptStringIfJavaScriptURL(requestURL);
835
836     if (jsString.isNull()) {
837         // if this is not a targeted request, create a stream for it. otherwise,
838         // just pass it off to the loader
839         if (request->frameLoadRequest().frameName().isEmpty()) {
840             PluginStreamWin* stream = new PluginStreamWin(this, m_parentFrame, request->frameLoadRequest().resourceRequest(), request->sendNotification(), request->notifyData());
841             m_streams.add(stream);
842             stream->start();
843         } else {
844             m_parentFrame->loader()->urlSelected(request->frameLoadRequest(), 0, false, true);
845       
846             // FIXME: <rdar://problem/4807469> This should be sent when the document has finished loading
847             if (request->sendNotification()) {
848                 KJS::JSLock::DropAllLocks dropAllLocks;
849                 setCallingPlugin(true);
850                 m_plugin->pluginFuncs()->urlnotify(m_instance, requestURL.deprecatedString().utf8(), NPRES_DONE, request->notifyData());
851                 setCallingPlugin(false);
852             }
853         }
854         return;
855     }
856
857     // Targeted JavaScript requests are only allowed on the frame that contains the JavaScript plugin
858     // and this has been made sure in ::load.
859     ASSERT(request->frameLoadRequest().frameName().isEmpty() || m_parentFrame->tree()->find(request->frameLoadRequest().frameName()) == m_parentFrame);
860     
861     // Executing a script can cause the plugin view to be destroyed, so we keep a reference to the parent frame.
862     RefPtr<Frame> parentFrame = m_parentFrame;
863     JSValue* result = m_parentFrame->loader()->executeScript(jsString, request->shouldAllowPopups());
864
865     if (request->frameLoadRequest().frameName().isNull()) {
866         String resultString;
867
868         CString cstr;
869         if (getString(parentFrame->scriptProxy(), result, resultString))
870             cstr = resultString.utf8();
871
872         RefPtr<PluginStreamWin> stream = new PluginStreamWin(this, parentFrame.get(), request->frameLoadRequest().resourceRequest(), request->sendNotification(), request->notifyData());
873         m_streams.add(stream);
874         stream->sendJavaScriptStream(requestURL, cstr);
875     }
876 }
877
878 void PluginViewWin::requestTimerFired(Timer<PluginViewWin>* timer)
879 {
880     ASSERT(timer == &m_requestTimer);
881     ASSERT(m_requests.size() > 0);
882
883     PluginRequestWin* request = m_requests[0];
884     m_requests.remove(0);
885     
886     // Schedule a new request before calling performRequest since the call to
887     // performRequest can cause the plugin view to be deleted.
888     if (m_requests.size() > 0)
889         m_requestTimer.startOneShot(0);
890
891     performRequest(request);
892 }
893
894 void PluginViewWin::scheduleRequest(PluginRequestWin* request)
895 {
896     m_requests.append(request);
897     m_requestTimer.startOneShot(0);
898 }
899
900 NPError PluginViewWin::load(const FrameLoadRequest& frameLoadRequest, bool sendNotification, void* notifyData)
901 {
902     ASSERT(frameLoadRequest.resourceRequest().httpMethod() == "GET" || frameLoadRequest.resourceRequest().httpMethod() == "POST");
903
904     KURL url = frameLoadRequest.resourceRequest().url();
905     
906     if (url.isEmpty())
907         return NPERR_INVALID_URL;
908
909     String target = frameLoadRequest.frameName();
910
911     // don't let a plugin start any loads if it is no longer part of a document that is being 
912     // displayed unless the loads are in the same frame as the plugin.
913     if (m_parentFrame->loader()->documentLoader() != m_parentFrame->loader()->activeDocumentLoader() &&
914         (target.isNull() || m_parentFrame->tree()->find(target) != m_parentFrame))
915         return NPERR_GENERIC_ERROR;
916
917     String jsString = scriptStringIfJavaScriptURL(url);
918     if (!jsString.isNull()) {
919         Settings* settings = m_parentFrame->settings();
920         if (!settings || !settings->isJavaScriptEnabled()) {
921             // Return NPERR_GENERIC_ERROR if JS is disabled. This is what Mozilla does.
922             return NPERR_GENERIC_ERROR;
923         } else if (target.isNull() && m_mode == NP_FULL) {
924             // Don't allow a JavaScript request from a standalone plug-in that is self-targetted
925             // because this can cause the user to be redirected to a blank page (3424039).
926             return NPERR_INVALID_PARAM;
927         }
928     }
929
930     if (!jsString.isNull() && !target.isNull() && m_parentFrame->tree()->find(target) != m_parentFrame) {
931         // For security reasons, only allow JS requests to be made on the frame that contains the plug-in.
932         return NPERR_INVALID_PARAM;
933     }
934
935     PluginRequestWin* request = new PluginRequestWin(frameLoadRequest, sendNotification, notifyData, arePopupsAllowed());
936     scheduleRequest(request);
937
938     return NPERR_NO_ERROR;
939 }
940
941 static KURL makeURL(const KURL& baseURL, const char* relativeURLString)
942 {
943     DeprecatedString urlString = DeprecatedString::fromLatin1(relativeURLString);
944
945     // Strip return characters
946     urlString.replace('\n', "");
947     urlString.replace('\r', "");
948
949     return KURL(baseURL, urlString);
950 }
951
952 NPError PluginViewWin::getURLNotify(const char* url, const char* target, void* notifyData)
953 {
954     FrameLoadRequest frameLoadRequest;
955
956     frameLoadRequest.setFrameName(target);
957     frameLoadRequest.resourceRequest().setHTTPMethod("GET");
958     frameLoadRequest.resourceRequest().setURL(makeURL(m_baseURL, url));
959
960     return load(frameLoadRequest, true, notifyData);
961 }
962
963 NPError PluginViewWin::getURL(const char* url, const char* target)
964 {
965     FrameLoadRequest frameLoadRequest;
966
967     frameLoadRequest.setFrameName(target);
968     frameLoadRequest.resourceRequest().setHTTPMethod("GET");
969     frameLoadRequest.resourceRequest().setURL(makeURL(m_baseURL, url));
970
971     return load(frameLoadRequest, false, 0);
972 }
973
974 static inline bool startsWithBlankLine(const Vector<char>& buffer)
975 {
976     return buffer.size() > 0 && buffer[0] == '\n';
977 }
978
979 static inline int locationAfterFirstBlankLine(const Vector<char>& buffer)
980 {
981     const char* bytes = buffer.data();
982     unsigned length = buffer.size();
983
984     for (unsigned i = 0; i < length - 4; i++) {
985         // Support for Acrobat. It sends "\n\n".
986         if (bytes[i] == '\n' && bytes[i + 1] == '\n')
987             return i + 2;
988         
989         // Returns the position after 2 CRLF's or 1 CRLF if it is the first line.
990         if (bytes[i] == '\r' && bytes[i + 1] == '\n') {
991             i += 2;
992             if (i == 2)
993                 return i;
994             else if (bytes[i] == '\n')
995                 // Support for Director. It sends "\r\n\n" (3880387).
996                 return i + 1;
997             else if (bytes[i] == '\r' && bytes[i + 1] == '\n')
998                 // Support for Flash. It sends "\r\n\r\n" (3758113).
999                 return i + 2;
1000         }
1001     }
1002
1003     return -1;
1004 }
1005
1006 static inline const char* findEOL(const char* bytes, unsigned length)
1007 {
1008     // According to the HTTP specification EOL is defined as
1009     // a CRLF pair. Unfortunately, some servers will use LF
1010     // instead. Worse yet, some servers will use a combination
1011     // of both (e.g. <header>CRLFLF<body>), so findEOL needs
1012     // to be more forgiving. It will now accept CRLF, LF or
1013     // CR.
1014     //
1015     // It returns NULL if EOLF is not found or it will return
1016     // a pointer to the first terminating character.
1017     for (unsigned i = 0; i < length; i++) {
1018         if (bytes[i] == '\n')
1019             return bytes + i;
1020         if (bytes[i] == '\r') {
1021             // Check to see if spanning buffer bounds
1022             // (CRLF is across reads). If so, wait for
1023             // next read.
1024             if (i + 1 == length)
1025                 break;
1026
1027             return bytes + i;
1028         }
1029     }
1030
1031     return 0;
1032 }
1033
1034 static inline String capitalizeRFC822HeaderFieldName(const String& name)
1035 {
1036     bool capitalizeCharacter = true;
1037     String result;
1038
1039     for (unsigned i = 0; i < name.length(); i++) {
1040         UChar c;
1041
1042         if (capitalizeCharacter && name[i] >= 'a' && name[i] <= 'z')
1043             c = toASCIIUpper(name[i]);
1044         else if (!capitalizeCharacter && name[i] >= 'A' && name[i] <= 'Z')
1045             c = toASCIILower(name[i]);
1046         else
1047             c = name[i];
1048
1049         if (name[i] == '-')
1050             capitalizeCharacter = true;
1051         else
1052             capitalizeCharacter = false;
1053
1054         result.append(c);
1055     }
1056
1057     return result;
1058 }
1059
1060 static inline HTTPHeaderMap parseRFC822HeaderFields(const Vector<char>& buffer, unsigned length)
1061 {
1062     const char* bytes = buffer.data();
1063     const char* eol;
1064     String lastKey;
1065     HTTPHeaderMap headerFields;
1066
1067     // Loop ove rlines until we're past the header, or we can't find any more end-of-lines
1068     while ((eol = findEOL(bytes, length))) {
1069         const char* line = bytes;
1070         int lineLength = eol - bytes;
1071         
1072         // Move bytes to the character after the terminator as returned by findEOL.
1073         bytes = eol + 1;
1074         if ((*eol == '\r') && (*bytes == '\n'))
1075             bytes++; // Safe since findEOL won't return a spanning CRLF.
1076
1077         length -= (bytes - line);
1078         if (lineLength == 0)
1079             // Blank line; we're at the end of the header
1080             break;
1081         else if (*line == ' ' || *line == '\t') {
1082             // Continuation of the previous header
1083             if (lastKey.isNull()) {
1084                 // malformed header; ignore it and continue
1085                 continue;
1086             } else {
1087                 // Merge the continuation of the previous header
1088                 String currentValue = headerFields.get(lastKey);
1089                 String newValue = DeprecatedString::fromLatin1(line, lineLength);
1090
1091                 headerFields.set(lastKey, currentValue + newValue);
1092             }
1093         } else {
1094             // Brand new header
1095             const char* colon;
1096             for (colon = line; *colon != ':' && colon != eol; colon++) {
1097                 // empty loop
1098             }
1099             if (colon == eol) 
1100                 // malformed header; ignore it and continue
1101                 continue;
1102             else {
1103                 lastKey = capitalizeRFC822HeaderFieldName(DeprecatedString::fromLatin1(line, colon - line));
1104                 String value;
1105
1106                 for (colon++; colon != eol; colon++) {
1107                     if (*colon != ' ' && *colon != '\t')
1108                         break;
1109                 }
1110                 if (colon == eol)
1111                     value = "";
1112                 else
1113                     value = DeprecatedString::fromLatin1(colon, eol - colon);
1114
1115                 String oldValue = headerFields.get(lastKey);
1116                 if (!oldValue.isNull()) {
1117                     String tmp = oldValue;
1118                     tmp += ", ";
1119                     tmp += value;
1120                     value = tmp;
1121                 }
1122
1123                 headerFields.set(lastKey, value);
1124             }
1125         }
1126     }
1127
1128     return headerFields;
1129 }
1130
1131 NPError PluginViewWin::handlePost(const char* url, const char* target, uint32 len, const char* buf, bool file, void* notifyData, bool sendNotification, bool allowHeaders)
1132 {
1133     if (!url || !len || !buf)
1134         return NPERR_INVALID_PARAM;
1135
1136     FrameLoadRequest frameLoadRequest;
1137
1138     HTTPHeaderMap headerFields;
1139     Vector<char> buffer;
1140     
1141     if (file) {
1142         String filename = DeprecatedString::fromLatin1(buf, len);
1143
1144         if (filename.startsWith("file:///"))
1145             filename = filename.substring(8);
1146
1147         // Get file info
1148         WIN32_FILE_ATTRIBUTE_DATA attrs;
1149         if (GetFileAttributesExW(filename.charactersWithNullTermination(), GetFileExInfoStandard, &attrs) == 0)
1150             return NPERR_FILE_NOT_FOUND;
1151
1152         if (attrs.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1153             return NPERR_FILE_NOT_FOUND;
1154
1155         HANDLE fileHandle = CreateFileW(filename.charactersWithNullTermination(), FILE_READ_DATA, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
1156         
1157         if (fileHandle == INVALID_HANDLE_VALUE)
1158             return NPERR_FILE_NOT_FOUND;
1159
1160         buffer.resize(attrs.nFileSizeLow);
1161
1162         DWORD bytesRead;
1163         int retval = ReadFile(fileHandle, buffer.data(), attrs.nFileSizeLow, &bytesRead, 0);
1164
1165         CloseHandle(fileHandle);
1166
1167         if (retval == 0 || bytesRead != attrs.nFileSizeLow)
1168             return NPERR_FILE_NOT_FOUND;
1169     } else {
1170         buffer.resize(len);
1171         memcpy(buffer.data(), buf, len);
1172     }
1173
1174     const char* postData = buffer.data();
1175     int postDataLength = buffer.size();
1176     
1177     if (allowHeaders) {
1178         if (startsWithBlankLine(buffer)) {
1179             postData++;
1180             postDataLength--;
1181         } else {
1182             int location = locationAfterFirstBlankLine(buffer);
1183             if (location != -1) {
1184                 // If the blank line is somewhere in the middle of the buffer, everything before is the header
1185                 headerFields = parseRFC822HeaderFields(buffer, location);
1186                 unsigned dataLength = buffer.size() - location;
1187
1188                 // Sometimes plugins like to set Content-Length themselves when they post,
1189                 // but WebFoundation does not like that. So we will remove the header
1190                 // and instead truncate the data to the requested length.
1191                 String contentLength = headerFields.get("Content-Length");
1192
1193                 if (!contentLength.isNull())
1194                     dataLength = min(contentLength.toInt(), (int)dataLength);
1195                 headerFields.remove("Content-Length");
1196
1197                 postData += location;
1198                 postDataLength = dataLength;
1199             }
1200         }
1201     }
1202
1203     frameLoadRequest.resourceRequest().setHTTPMethod("POST");
1204     frameLoadRequest.resourceRequest().setURL(makeURL(m_baseURL, url));
1205     frameLoadRequest.resourceRequest().addHTTPHeaderFields(headerFields);
1206     frameLoadRequest.resourceRequest().setHTTPBody(PassRefPtr<FormData>(new FormData(postData, postDataLength)));
1207     frameLoadRequest.setFrameName(target);
1208
1209     return load(frameLoadRequest, sendNotification, notifyData);
1210 }
1211
1212 NPError PluginViewWin::postURLNotify(const char* url, const char* target, uint32 len, const char* buf, NPBool file, void* notifyData)
1213 {
1214     return handlePost(url, target, len, buf, file, notifyData, true, true);
1215 }
1216
1217 NPError PluginViewWin::postURL(const char* url, const char* target, uint32 len, const char* buf, NPBool file)
1218 {
1219     // As documented, only allow headers to be specified via NPP_PostURL when using a file.
1220     return handlePost(url, target, len, buf, file, 0, false, file);
1221 }
1222
1223 NPError PluginViewWin::newStream(NPMIMEType type, const char* target, NPStream** stream)
1224 {
1225     notImplemented();
1226     // Unsupported
1227     return NPERR_GENERIC_ERROR;
1228 }
1229
1230 int32 PluginViewWin::write(NPStream* stream, int32 len, void* buffer)
1231 {
1232     notImplemented();
1233     // Unsupported
1234     return -1;
1235 }
1236
1237 NPError PluginViewWin::destroyStream(NPStream* stream, NPReason reason)
1238 {
1239     PluginStreamWin* browserStream = static_cast<PluginStreamWin*>(stream->ndata);
1240
1241     if (!stream || PluginStreamWin::ownerForStream(stream) != m_instance)
1242         return NPERR_INVALID_INSTANCE_ERROR;
1243
1244     browserStream->cancelAndDestroyStream(reason);
1245     return NPERR_NO_ERROR;
1246 }
1247
1248 const char* PluginViewWin::userAgent()
1249 {
1250     if (m_quirks & PluginQuirkWantsMozillaUserAgent)
1251         return MozillaUserAgent;
1252
1253     if (m_userAgent.isNull())
1254         m_userAgent = m_parentFrame->loader()->userAgent(m_url).utf8();
1255     return m_userAgent.data();
1256 }
1257
1258 void PluginViewWin::status(const char* message)
1259 {
1260     String s = DeprecatedString::fromLatin1(message);
1261
1262     if (Page* page = m_parentFrame->page())
1263         page->chrome()->setStatusbarText(m_parentFrame, s);
1264 }
1265
1266 NPError PluginViewWin::getValue(NPNVariable variable, void* value)
1267 {
1268     switch (variable) {
1269         case NPNVWindowNPObject: {
1270             NPObject* windowScriptObject = m_parentFrame->windowScriptNPObject();
1271
1272             // Return value is expected to be retained, as described here: <http://www.mozilla.org/projects/plugin/npruntime.html>
1273             if (windowScriptObject)
1274                 _NPN_RetainObject(windowScriptObject);
1275
1276             void** v = (void**)value;
1277             *v = windowScriptObject;
1278             
1279             return NPERR_NO_ERROR;
1280         }
1281
1282         case NPNVPluginElementNPObject: {
1283             NPObject* pluginScriptObject = 0;
1284
1285             if (m_element->hasTagName(appletTag) || m_element->hasTagName(embedTag) || m_element->hasTagName(objectTag))
1286                 pluginScriptObject = static_cast<HTMLPlugInElement*>(m_element)->getNPObject();
1287
1288             // Return value is expected to be retained, as described here: <http://www.mozilla.org/projects/plugin/npruntime.html>
1289             if (pluginScriptObject)
1290                 _NPN_RetainObject(pluginScriptObject);
1291
1292             void** v = (void**)value;
1293             *v = pluginScriptObject;
1294
1295             return NPERR_NO_ERROR;
1296         }
1297
1298         case NPNVnetscapeWindow: {
1299             HWND* w = reinterpret_cast<HWND*>(value);
1300
1301             *w = containingWindow();
1302
1303             return NPERR_NO_ERROR;
1304         }
1305         default:
1306             return NPERR_GENERIC_ERROR;
1307     }
1308 }
1309
1310 NPError PluginViewWin::setValue(NPPVariable variable, void* value)
1311 {
1312     switch (variable) {
1313         case NPPVpluginWindowBool:
1314             m_isWindowed = value;
1315             return NPERR_NO_ERROR;
1316         case NPPVpluginTransparentBool:
1317             m_isTransparent = value;
1318             return NPERR_NO_ERROR;
1319         default:
1320             notImplemented();
1321             return NPERR_GENERIC_ERROR;
1322     }
1323 }
1324
1325 void PluginViewWin::invalidateTimerFired(Timer<PluginViewWin>* timer)
1326 {
1327     ASSERT(timer == &m_invalidateTimer);
1328
1329     for (unsigned i = 0; i < m_invalidRects.size(); i++)
1330         Widget::invalidateRect(m_invalidRects[i]);
1331     m_invalidRects.clear();
1332 }
1333
1334
1335 void PluginViewWin::invalidateRect(NPRect* rect)
1336 {
1337     if (!rect) {
1338         invalidate();
1339         return;
1340     }
1341
1342     IntRect r(rect->left, rect->top, rect->right - rect->left, rect->bottom - rect->top);
1343
1344     if (m_isWindowed) {
1345         RECT invalidRect(r);
1346         InvalidateRect(m_window, &invalidRect, FALSE);
1347     } else {
1348         if (m_quirks & PluginQuirkThrottleInvalidate) {
1349             m_invalidRects.append(r);
1350             if (!m_invalidateTimer.isActive())
1351                 m_invalidateTimer.startOneShot(0.001);
1352         } else
1353             Widget::invalidateRect(r);
1354     }
1355 }
1356
1357 void PluginViewWin::invalidateRegion(NPRegion region)
1358 {
1359     if (m_isWindowed)
1360         return;
1361
1362     RECT r;
1363
1364     if (GetRgnBox(region, &r) == 0) {
1365         invalidate();
1366         return;
1367     }
1368
1369     Widget::invalidateRect(r);
1370 }
1371
1372 void PluginViewWin::forceRedraw()
1373 {
1374     if (m_isWindowed)
1375         ::UpdateWindow(m_window);
1376     else
1377         ::UpdateWindow(containingWindow());
1378 }
1379
1380 void PluginViewWin::pushPopupsEnabledState(bool state)
1381 {
1382     m_popupStateStack.append(state);
1383 }
1384  
1385 void PluginViewWin::popPopupsEnabledState()
1386 {
1387     m_popupStateStack.removeLast();
1388 }
1389
1390 bool PluginViewWin::arePopupsAllowed() const
1391 {
1392     if (!m_popupStateStack.isEmpty())
1393         return m_popupStateStack.last();
1394
1395     return false;
1396 }
1397
1398 KJS::Bindings::Instance* PluginViewWin::bindingInstance()
1399 {
1400     NPObject* object = 0;
1401
1402     if (!m_plugin || !m_plugin->pluginFuncs()->getvalue)
1403         return 0;
1404
1405     NPError npErr;
1406     {
1407         KJS::JSLock::DropAllLocks dropAllLocks;
1408         setCallingPlugin(true);
1409         npErr = m_plugin->pluginFuncs()->getvalue(m_instance, NPPVpluginScriptableNPObject, &object);
1410         setCallingPlugin(false);
1411     }
1412
1413     if (npErr != NPERR_NO_ERROR || !object)
1414         return 0;
1415
1416     RefPtr<KJS::Bindings::RootObject> root = m_parentFrame->createRootObject(this, m_parentFrame->scriptProxy()->globalObject());
1417     KJS::Bindings::Instance *instance = KJS::Bindings::Instance::createBindingForLanguageInstance(KJS::Bindings::Instance::CLanguage, object, root.release());
1418
1419     _NPN_ReleaseObject(object);
1420
1421     return instance;
1422 }
1423
1424 PluginViewWin::~PluginViewWin()
1425 {
1426     stop();
1427
1428     deleteAllValues(m_requests);
1429
1430     freeStringArray(m_paramNames, m_paramCount);
1431     freeStringArray(m_paramValues, m_paramCount);
1432
1433     if (m_window)
1434         DestroyWindow(m_window);
1435
1436     m_parentFrame->cleanupScriptObjectsForPlugin(this);
1437
1438     if (m_plugin && !(m_quirks & PluginQuirkDontUnloadPlugin))
1439         m_plugin->unload();
1440 }
1441
1442 void PluginViewWin::disconnectStream(PluginStreamWin* stream)
1443 {
1444     ASSERT(m_streams.contains(stream));
1445
1446     m_streams.remove(stream);
1447 }
1448
1449 void PluginViewWin::determineQuirks(const String& mimeType)
1450 {
1451     // The flash plugin only requests windowless plugins if we return a mozilla user agent
1452     if (mimeType == "application/x-shockwave-flash") {
1453         m_quirks |= PluginQuirkWantsMozillaUserAgent;
1454         m_quirks |= PluginQuirkThrottleInvalidate;
1455         m_quirks |= PluginQuirkThrottleWMUserPlusOneMessages;
1456     }
1457
1458     // The WMP plugin sets its size on the first NPP_SetWindow call and never updates its size, so
1459     // call SetWindow when the plugin view has a correct size
1460     if (m_plugin->name().contains("Microsoft") && m_plugin->name().contains("Windows Media")) {
1461         m_quirks |= PluginQuirkDeferFirstSetWindowCall;
1462
1463         // Windowless mode does not work at all with the WMP plugin so just remove that parameter 
1464         // and don't pass it to the plug-in.
1465         m_quirks |= PluginQuirkRemoveWindowlessVideoParam;
1466
1467         // WMP has a modal message loop that it enters whenever we call it or
1468         // ask it to paint. This modal loop can deliver messages to other
1469         // windows in WebKit at times when they are not expecting them (for
1470         // example, delivering a WM_PAINT message during a layout), and these
1471         // can cause crashes.
1472         m_quirks |= PluginQuirkHasModalMessageLoop;
1473     }
1474
1475     // The DivX plugin sets its size on the first NPP_SetWindow call and never updates its size, so
1476     // call SetWindow when the plugin view has a correct size
1477     if (mimeType == "video/divx")
1478         m_quirks |= PluginQuirkDeferFirstSetWindowCall;
1479
1480     // FIXME: This is a workaround for a problem in our NPRuntime bindings; if a plug-in creates an
1481     // NPObject and passes it to a function it's not possible to see what root object that NPObject belongs to.
1482     // Thus, we don't know that the object should be invalidated when the plug-in instance goes away.
1483     // See <rdar://problem/5487742>.
1484     if (mimeType == "application/x-silverlight")
1485         m_quirks |= PluginQuirkDontUnloadPlugin;
1486
1487     // Because a single process cannot create multiple VMs, and we cannot reliably unload a
1488     // Java VM, we cannot unload the Java plugin, or we'll lose reference to our only VM
1489     if (MIMETypeRegistry::isJavaAppletMIMEType(mimeType))
1490         m_quirks |= PluginQuirkDontUnloadPlugin;
1491
1492     // Prevent the Real plugin from calling the Window Proc recursively, causing the stack to overflow.
1493     if (mimeType == "audio/x-pn-realaudio-plugin")
1494         m_quirks |= PluginQuirkDontCallWndProcForSameMessageRecursively;
1495 }
1496
1497 void PluginViewWin::setParameters(const Vector<String>& paramNames, const Vector<String>& paramValues)
1498 {
1499     ASSERT(paramNames.size() == paramValues.size());
1500
1501     unsigned size = paramNames.size();
1502     unsigned paramCount = 0;
1503
1504     m_paramNames = reinterpret_cast<char**>(fastMalloc(sizeof(char*) * size));
1505     m_paramValues = reinterpret_cast<char**>(fastMalloc(sizeof(char*) * size));
1506
1507     for (unsigned i = 0; i < size; i++) {
1508         if ((m_quirks & PluginQuirkRemoveWindowlessVideoParam) && equalIgnoringCase(paramNames[i], "windowlessvideo"))
1509             continue;
1510
1511         m_paramNames[paramCount] = createUTF8String(paramNames[i]);
1512         m_paramValues[paramCount] = createUTF8String(paramValues[i]);
1513
1514         paramCount++;
1515     }
1516
1517     m_paramCount = paramCount;
1518 }
1519
1520 PluginViewWin::PluginViewWin(Frame* parentFrame, const IntSize& size, PluginPackageWin* plugin, Element* element, const KURL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
1521     : m_parentFrame(parentFrame)
1522     , m_plugin(plugin)
1523     , m_element(element)
1524     , m_isStarted(false)
1525     , m_url(url)
1526     , m_baseURL(m_parentFrame->loader()->completeURL(m_parentFrame->document()->baseURL()))
1527     , m_status(PluginStatusLoadedSuccessfully)
1528     , m_requestTimer(this, &PluginViewWin::requestTimerFired)
1529     , m_invalidateTimer(this, &PluginViewWin::invalidateTimerFired)
1530     , m_popPopupsStateTimer(this, &PluginViewWin::popPopupsStateTimerFired)
1531     , m_paramNames(0)
1532     , m_paramValues(0)
1533     , m_window(0)
1534     , m_pluginWndProc(0)
1535     , m_quirks(0)
1536     , m_isWindowed(true)
1537     , m_isTransparent(false)
1538     , m_isVisible(false)
1539     , m_attachedToWindow(false)
1540     , m_haveInitialized(false)
1541     , m_lastMessage(0)
1542     , m_isCallingPluginWndProc(false)
1543     , m_loadManually(loadManually)
1544     , m_manualStream(0)
1545 {
1546     if (!m_plugin) {
1547         m_status = PluginStatusCanNotFindPlugin;
1548         return;
1549     }
1550
1551     m_instance = &m_instanceStruct;
1552     m_instance->ndata = this;
1553
1554     m_mimeType = mimeType.utf8();
1555     determineQuirks(mimeType);
1556
1557     setParameters(paramNames, paramValues);
1558
1559     m_mode = m_loadManually ? NP_FULL : NP_EMBED;
1560
1561     resize(size);
1562 }
1563
1564 void PluginViewWin::init()
1565 {
1566     if (m_haveInitialized)
1567         return;
1568     m_haveInitialized = true;
1569
1570     if (!m_plugin) {
1571         ASSERT(m_status == PluginStatusCanNotFindPlugin);
1572         return;
1573     }
1574
1575     if (!m_plugin->load()) {
1576         m_plugin = 0;
1577         m_status = PluginStatusCanNotLoadPlugin;
1578         return;
1579     }
1580
1581     if (!start()) {
1582         m_status = PluginStatusCanNotLoadPlugin;
1583         return;
1584     }
1585
1586     if (m_isWindowed) {
1587         registerPluginView();
1588
1589         DWORD flags = WS_CHILD;
1590         if (m_isVisible)
1591             flags |= WS_VISIBLE;
1592
1593         m_window = CreateWindowEx(0, kWebPluginViewWindowClassName, 0, flags,
1594                                   0, 0, 0, 0, m_parentFrame->view()->containingWindow(), 0, Page::instanceHandle(), 0);
1595         
1596         // Calling SetWindowLongPtrA here makes the window proc ASCII, which is required by at least
1597         // the Shockwave Director plug-in.
1598         ::SetWindowLongPtrA(m_window, GWL_WNDPROC, (LONG)DefWindowProcA);
1599
1600         SetProp(m_window, kWebPluginViewProperty, this);
1601
1602         m_npWindow.type = NPWindowTypeWindow;
1603         m_npWindow.window = m_window;
1604     } else {
1605         m_npWindow.type = NPWindowTypeDrawable;
1606         m_npWindow.window = 0;
1607     }
1608
1609     if (!(m_quirks & PluginQuirkDeferFirstSetWindowCall))
1610         setNPWindowRect(frameGeometry());
1611
1612     m_status = PluginStatusLoadedSuccessfully;
1613 }
1614
1615 void PluginViewWin::didReceiveResponse(const ResourceResponse& response)
1616 {
1617     ASSERT(m_loadManually);
1618     ASSERT(!m_manualStream);
1619
1620     m_manualStream = new PluginStreamWin(this, m_parentFrame, m_parentFrame->loader()->activeDocumentLoader()->request(), false, 0);
1621     m_manualStream->setLoadManually(true);
1622
1623     m_manualStream->didReceiveResponse(0, response);
1624 }
1625
1626 void PluginViewWin::didReceiveData(const char* data, int length)
1627 {
1628     ASSERT(m_loadManually);
1629     ASSERT(m_manualStream);
1630     
1631     m_manualStream->didReceiveData(0, data, length);
1632 }
1633
1634 void PluginViewWin::didFinishLoading()
1635 {
1636     ASSERT(m_loadManually);
1637     ASSERT(m_manualStream);
1638
1639     m_manualStream->didFinishLoading(0);
1640 }
1641
1642 void PluginViewWin::didFail(const ResourceError& error)
1643 {
1644     ASSERT(m_loadManually);
1645     ASSERT(m_manualStream);
1646
1647     m_manualStream->didFail(0, error);
1648 }
1649
1650 void PluginViewWin::setCallingPlugin(bool b) const
1651 {
1652     if (!(m_quirks & PluginQuirkHasModalMessageLoop))
1653         return;
1654
1655     if (b)
1656         ++s_callingPlugin;
1657     else
1658         --s_callingPlugin;
1659
1660     ASSERT(s_callingPlugin >= 0);
1661 }
1662
1663 bool PluginViewWin::isCallingPlugin()
1664 {
1665     return s_callingPlugin > 0;
1666 }
1667
1668 } // namespace WebCore