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