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