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