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