Fix more signed/unsigned mismatches uncovered by MSVC /W3
[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 "Element.h"
31 #include "EventNames.h"
32 #include "FrameLoader.h"
33 #include "FrameLoadRequest.h"
34 #include "FrameTree.h"
35 #include "Frame.h"
36 #include "FrameView.h"
37 #include "GraphicsContext.h"
38 #include "Image.h"
39 #include "HTMLNames.h"
40 #include "HTMLPlugInElement.h"
41 #include "KeyboardEvent.h"
42 #include "MouseEvent.h"
43 #include "NotImplemented.h"
44 #include "Page.h"
45 #include "PlatformMouseEvent.h"
46 #include "PluginPackageWin.h"
47 #include "kjs_binding.h"
48 #include "kjs_proxy.h"
49 #include "kjs_window.h"
50 #include "PluginDebug.h"
51 #include "PluginPackageWin.h"
52 #include "PluginStreamWin.h"
53 #include "npruntime_impl.h"
54 #include "runtime_root.h"
55 #include "Settings.h"
56 #include <kjs/JSLock.h>
57 #include <kjs/value.h>
58
59 using KJS::ExecState;
60 using KJS::Interpreter;
61 using KJS::JSLock;
62 using KJS::JSObject;
63 using KJS::JSValue;
64 using KJS::UString;
65 using KJS::Window;
66
67 using std::min;
68
69 namespace WebCore {
70
71 using namespace EventNames;
72 using namespace HTMLNames;
73
74 class PluginRequestWin {
75 public:
76     PluginRequestWin(const FrameLoadRequest& frameLoadRequest, bool sendNotification, void* notifyData)
77         : m_frameLoadRequest(frameLoadRequest)
78         , m_notifyData(notifyData)
79         , m_sendNotification(sendNotification) { }
80 public:
81     const FrameLoadRequest& frameLoadRequest() const { return m_frameLoadRequest; }
82     void* notifyData() const { return m_notifyData; }
83     bool sendNotification() const { return m_sendNotification; }
84 private:
85     FrameLoadRequest m_frameLoadRequest;
86     void* m_notifyData;
87     bool m_sendNotification;
88     // FIXME: user gesture
89 };
90
91 static String scriptStringIfJavaScriptURL(const KURL& url)
92 {
93     if (!url.url().startsWith("javascript:", false))
94         return String();
95
96     // This returns an unescaped string
97     return KURL::decode_string(url.url().mid(11));
98 }
99
100 PluginViewWin* PluginViewWin::s_currentPluginView = 0;
101
102 const LPCWSTR kWebPluginViewWindowClassName = L"WebPluginView";
103 const LPCWSTR kWebPluginViewProperty = L"WebPluginViewProperty";
104
105 static const char* MozillaUserAgent = "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1) Gecko/20061010 Firefox/2.0";
106
107 static LRESULT CALLBACK PluginViewWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
108
109 static bool registerPluginView()
110 {
111     static bool haveRegisteredWindowClass = false;
112     if (haveRegisteredWindowClass)
113         return true;
114
115     ASSERT(Page::instanceHandle());
116
117     WNDCLASSEX wcex;
118
119     wcex.cbSize = sizeof(WNDCLASSEX);
120
121     wcex.style          = CS_DBLCLKS;
122     wcex.lpfnWndProc    = PluginViewWndProc;
123     wcex.cbClsExtra     = 0;
124     wcex.cbWndExtra     = 0;
125     wcex.hInstance      = Page::instanceHandle();
126     wcex.hIcon          = 0;
127     wcex.hCursor        = LoadCursor(0, IDC_ARROW);
128     wcex.hbrBackground  = (HBRUSH)COLOR_WINDOW;
129     wcex.lpszMenuName   = 0;
130     wcex.lpszClassName  = kWebPluginViewWindowClassName;
131     wcex.hIconSm        = 0;
132
133     return RegisterClassEx(&wcex);
134 }
135
136 static LRESULT CALLBACK PluginViewWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
137 {
138     PluginViewWin* pluginView = reinterpret_cast<PluginViewWin*>(GetProp(hWnd, kWebPluginViewProperty));
139
140     if (pluginView && (pluginView->quirks() & PluginQuirksWantsAsciiWindowProc))
141         return DefWindowProcA(hWnd, message, wParam, lParam);
142     else 
143         return DefWindowProcW(hWnd, message, wParam, lParam);
144 }
145
146 void PluginViewWin::updateWindow() const
147 {
148     ASSERT(parent()->isFrameView());
149     FrameView* frameView = static_cast<FrameView*>(parent());
150
151     IntRect oldWindowRect = m_windowRect;
152     IntRect oldClipRect = m_clipRect;
153
154     m_windowRect = IntRect(frameView->contentsToWindow(frameGeometry().location()), frameGeometry().size());
155     m_clipRect = windowClipRect();
156     m_clipRect.move(-m_windowRect.x(), -m_windowRect.y());
157
158     if (m_window && (m_windowRect != oldWindowRect || m_clipRect != oldClipRect)) {
159         HRGN rgn;
160
161         // To prevent flashes while scrolling, we disable drawing during the window
162         // update process by clipping the window to the zero rect.
163
164         // FIXME: Setting the window region to an empty region causes bad scrolling 
165         // repaint problems with at least the WMP and Java plugins.
166         // <rdar://problem/5211187> Come up with a better way of handling plug-in scrolling
167         // is the bug that tracks the work of fixing this.
168         //rgn = ::CreateRectRgn(0, 0, 0, 0);
169         //::SetWindowRgn(m_window, rgn, false);
170
171         if (m_windowRect != oldWindowRect)
172             ::MoveWindow(m_window, m_windowRect.x(), m_windowRect.y(), m_windowRect.width(), m_windowRect.height(), true);
173
174         // Re-enable drawing. (This serves the double purpose of updating the clip rect if it has changed.)
175         rgn = ::CreateRectRgn(m_clipRect.x(), m_clipRect.y(), m_clipRect.right(), m_clipRect.bottom());
176         ::SetWindowRgn(m_window, rgn, true);
177         ::UpdateWindow(m_window);
178     }
179 }
180
181 IntRect PluginViewWin::windowClipRect() const
182 {
183     // Start by clipping to our bounds.
184     IntRect clipRect(m_windowRect);
185     
186     // Take our element and get the clip rect from the enclosing layer and frame view.
187     RenderLayer* layer = m_element->renderer()->enclosingLayer();
188     FrameView* parentView = m_element->document()->view();
189     clipRect.intersect(parentView->windowClipRectForLayer(layer, true));
190
191     return clipRect;
192 }
193
194 void PluginViewWin::setFrameGeometry(const IntRect& rect)
195 {
196     if (m_element->document()->printing())
197         return;
198
199     if (rect == frameGeometry())
200         return;
201
202     Widget::setFrameGeometry(rect);
203
204     updateWindow();
205
206     setNPWindowRect(rect);
207 }
208
209 void PluginViewWin::geometryChanged() const
210 {
211     updateWindow();
212 }
213
214 void PluginViewWin::setFocus()
215 {
216     if (HWND window = m_window)
217         SetFocus(window);
218
219     Widget::setFocus();
220 }
221
222 void PluginViewWin::show()
223 {
224     m_isVisible = true;
225
226     if (HWND window = m_window)
227         ShowWindow(window, SW_SHOWNA);
228
229     Widget::show();
230 }
231
232 void PluginViewWin::hide()
233 {
234     m_isVisible = false;
235
236     if (HWND window = m_window)
237         ShowWindow(window, SW_HIDE);
238
239     Widget::hide();
240 }
241
242 void PluginViewWin::paintMissingPluginIcon(GraphicsContext* context, const IntRect& rect)
243 {
244     static Image* nullPluginImage;
245     if (!nullPluginImage)
246         nullPluginImage = Image::loadPlatformResource("nullPlugin");
247
248     IntRect imageRect(frameGeometry().x(), frameGeometry().y(), nullPluginImage->width(), nullPluginImage->height());
249
250     int xOffset = (frameGeometry().width() - imageRect.width()) / 2;
251     int yOffset = (frameGeometry().height() - imageRect.height()) / 2;
252
253     imageRect.move(xOffset, yOffset);
254
255     if (!rect.intersects(imageRect))
256         return;
257
258     context->save();
259     context->clip(windowClipRect());
260     context->drawImage(nullPluginImage, imageRect.location());
261     context->restore();
262 }
263
264 void PluginViewWin::paint(GraphicsContext* context, const IntRect& rect)
265 {
266     if (!m_isStarted) {
267         // Draw the "missing plugin" image
268         paintMissingPluginIcon(context, rect);
269         return;
270     }
271
272     if (m_isWindowed || context->paintingDisabled())
273         return;
274
275     HDC hdc = context->getWindowsContext();
276
277     // The plugin expects that the passed in DC has window coordinates.
278     // (This probably breaks funky SVG transform stuff)
279     XFORM transform;
280     GetWorldTransform(hdc, &transform);
281     transform.eDx = 0;
282     transform.eDy = 0;
283     SetWorldTransform(hdc, &transform);
284
285     NPEvent npEvent;
286
287     m_npWindow.type = NPWindowTypeDrawable;
288     m_npWindow.window = hdc;
289
290     ASSERT(parent()->isFrameView());
291     IntPoint p = static_cast<FrameView*>(parent())->contentsToWindow(frameGeometry().location());
292     
293     WINDOWPOS windowpos;
294     memset(&windowpos, 0, sizeof(windowpos));
295
296     windowpos.x = p.x();
297     windowpos.y = p.y();
298     windowpos.cx = frameGeometry().width();
299     windowpos.cy = frameGeometry().height();
300
301     npEvent.event = WM_WINDOWPOSCHANGED;
302     npEvent.lParam = reinterpret_cast<uint32>(&windowpos);
303     npEvent.wParam = 0;
304
305     if (m_plugin->pluginFuncs()->event) {
306         KJS::JSLock::DropAllLocks dropAllLocks;
307         m_plugin->pluginFuncs()->event(m_instance, &npEvent);
308     }
309
310     setNPWindowRect(frameGeometry());
311
312     npEvent.event = WM_PAINT;
313     npEvent.wParam = reinterpret_cast<uint32>(hdc);
314
315     // This is supposed to be a pointer to the dirty rect, but it seems that the Flash plugin 
316     // ignores it so we just pass null.
317     npEvent.lParam = 0;
318
319     if (m_plugin->pluginFuncs()->event) {
320         KJS::JSLock::DropAllLocks dropAllLocks;
321         m_plugin->pluginFuncs()->event(m_instance, &npEvent);
322     }
323
324     context->releaseWindowsContext(hdc);
325 }
326
327 void PluginViewWin::handleKeyboardEvent(KeyboardEvent* event)
328 {
329     NPEvent npEvent;
330
331     npEvent.wParam = event->keyCode();    
332
333     if (event->type() == keydownEvent) {
334         npEvent.event = WM_KEYDOWN;
335         npEvent.lParam = 0;
336     } else if (event->type() == keyupEvent) {
337         npEvent.event = WM_KEYUP;
338         npEvent.lParam = 0x8000;
339     }
340
341     KJS::JSLock::DropAllLocks;
342     if (!m_plugin->pluginFuncs()->event(m_instance, &npEvent))
343         event->setDefaultHandled();
344 }
345
346 extern HCURSOR lastSetCursor;
347 extern bool ignoreNextSetCursor;
348
349 void PluginViewWin::handleMouseEvent(MouseEvent* event)
350 {
351     NPEvent npEvent;
352
353     IntPoint p = static_cast<FrameView*>(parent())->contentsToWindow(IntPoint(event->pageX(), event->pageY()));
354
355     npEvent.lParam = MAKELPARAM(p.x(), p.y());
356     npEvent.wParam = 0;
357
358     if (event->ctrlKey())
359         npEvent.wParam |= MK_CONTROL;
360     if (event->shiftKey())
361         npEvent.wParam |= MK_SHIFT;
362
363     if (event->type() == mousemoveEvent) {
364         npEvent.event = WM_MOUSEMOVE;
365         if (event->buttonDown())
366             switch (event->button()) {
367                 case LeftButton:
368                     npEvent.wParam |= MK_LBUTTON;
369                     break;
370                 case MiddleButton:
371                     npEvent.wParam |= MK_MBUTTON;
372                     break;
373                 case RightButton:
374                     npEvent.wParam |= MK_RBUTTON;
375                 break;
376             }
377     }
378     else if (event->type() == mousedownEvent) {
379         switch (event->button()) {
380             case 0:
381                 npEvent.event = WM_LBUTTONDOWN;
382
383                 // Focus the plugin
384                 m_parentFrame->document()->setFocusedNode(m_element);
385                 break;
386             case 1:
387                 npEvent.event = WM_MBUTTONDOWN;
388                 break;
389             case 2:
390                 npEvent.event = WM_RBUTTONDOWN;
391                 break;
392         }
393     } else if (event->type() == mouseupEvent) {
394         switch (event->button()) {
395             case 0:
396                 npEvent.event = WM_LBUTTONUP;
397                 break;
398             case 1:
399                 npEvent.event = WM_MBUTTONUP;
400                 break;
401             case 2:
402                 npEvent.event = WM_RBUTTONUP;
403                 break;
404         }
405     } else 
406         return;
407
408     HCURSOR currentCursor = ::GetCursor();
409
410     KJS::JSLock::DropAllLocks;
411     if (!m_plugin->pluginFuncs()->event(m_instance, &npEvent))
412         event->setDefaultHandled();
413
414     // Currently, Widget::setCursor is always called after this function in EventHandler.cpp
415     // and since we don't want that we set ignoreNextSetCursor to true here to prevent that.
416     ignoreNextSetCursor = true;     
417     lastSetCursor = ::GetCursor();
418 }
419
420 void PluginViewWin::handleEvent(Event* event)
421 {
422     if (!m_plugin || m_isWindowed)
423         return;
424
425     if (event->isMouseEvent())
426         handleMouseEvent(static_cast<MouseEvent*>(event));
427     else if (event->isKeyboardEvent())
428         handleKeyboardEvent(static_cast<KeyboardEvent*>(event));
429 }
430
431 void PluginViewWin::setParent(ScrollView* parent)
432 {
433     Widget::setParent(parent);
434     init();
435 }
436
437 void PluginViewWin::setNPWindowRect(const IntRect& rect)
438 {
439     if (!m_isStarted)
440         return;
441
442     IntPoint p = static_cast<FrameView*>(parent())->contentsToWindow(rect.location());
443     m_npWindow.x = p.x();
444     m_npWindow.y = p.y();
445
446     m_npWindow.width = rect.width();
447     m_npWindow.height = rect.height();
448
449     m_npWindow.clipRect.left = 0;
450     m_npWindow.clipRect.top = 0;
451     m_npWindow.clipRect.right = rect.width();
452     m_npWindow.clipRect.bottom = rect.height();
453
454     if (m_plugin->pluginFuncs()->setwindow) {
455         KJS::JSLock::DropAllLocks dropAllLocks;
456         m_plugin->pluginFuncs()->setwindow(m_instance, &m_npWindow);
457     }
458 }
459
460 bool PluginViewWin::start()
461 {
462     if (m_isStarted)
463         return false;
464
465     ASSERT(m_plugin);
466     ASSERT(m_plugin->pluginFuncs()->newp);
467
468     NPError npErr;
469     PluginViewWin::setCurrentPluginView(this);
470     {
471         KJS::JSLock::DropAllLocks dropAllLocks;
472         npErr = m_plugin->pluginFuncs()->newp((NPMIMEType)(const char*)m_mimeType, m_instance, m_mode, m_paramCount, m_paramNames, m_paramValues, NULL);
473         LOG_NPERROR(npErr);
474     }
475     PluginViewWin::setCurrentPluginView(0);
476
477     if (npErr != NPERR_NO_ERROR)
478         return false;
479
480     m_isStarted = true;
481
482     if (m_url.isValid()) {
483         FrameLoadRequest frameLoadRequest;
484         frameLoadRequest.resourceRequest().setHTTPMethod("GET");
485         frameLoadRequest.resourceRequest().setURL(m_url);
486         load(frameLoadRequest, false, 0);
487     }
488
489     return true;
490 }
491
492 void PluginViewWin::stop()
493 {
494     if (!m_isStarted)
495         return;
496
497     HashSet<RefPtr<PluginStreamWin> > streams = m_streams;
498     HashSet<RefPtr<PluginStreamWin> >::iterator end = streams.end();
499     for (HashSet<RefPtr<PluginStreamWin> >::iterator it = streams.begin(); it != end; ++it) {
500         (*it)->stop();
501         disconnectStream((*it).get());
502     }
503
504     ASSERT(m_streams.isEmpty());
505
506     m_isStarted = false;
507
508     KJS::JSLock::DropAllLocks;
509
510     // Clear the window
511     m_npWindow.window = 0;
512     if (m_plugin->pluginFuncs()->setwindow)
513         m_plugin->pluginFuncs()->setwindow(m_instance, &m_npWindow);
514
515     // Destroy the plugin
516     NPError npErr = m_plugin->pluginFuncs()->destroy(m_instance, 0);
517     LOG_NPERROR(npErr);
518
519     m_instance->pdata = 0;
520 }
521
522 void PluginViewWin::setCurrentPluginView(PluginViewWin* pluginView)
523 {
524     s_currentPluginView = pluginView;
525 }
526
527 PluginViewWin* PluginViewWin::currentPluginView()
528 {
529     return s_currentPluginView;
530 }
531
532 static char* createUTF8String(const String& str)
533 {
534     CString cstr = str.utf8();
535     char* result = reinterpret_cast<char*>(fastMalloc(cstr.length() + 1));
536
537     strncpy(result, cstr, cstr.length() + 1);
538
539     return result;
540 }
541
542 static char** createUTF8StringArray(const Vector<String>& vector)
543 {
544     char** result = reinterpret_cast<char**>(fastMalloc(sizeof(char*) * vector.size()));
545
546     for (unsigned i = 0; i < vector.size(); i++)
547         result[i] = createUTF8String(vector[i]);
548
549     return result;
550 }
551
552 static void freeStringArray(char** stringArray, int length)
553 {
554     if (!stringArray)
555         return;
556
557     for (int i = 0; i < length; i++)
558         fastFree(stringArray[i]);
559
560     fastFree(stringArray);
561 }
562
563 static bool getString(KJSProxy* proxy, JSValue* result, String& string)
564 {
565     if (!proxy || !result || result->isUndefined())
566         return false;
567     JSLock lock;
568
569     ExecState* exec = proxy->interpreter()->globalExec();
570     UString ustring = result->toString(exec);
571     exec->clearException();
572     
573     string = ustring;
574     return true;
575 }
576
577 void PluginViewWin::performRequest(PluginRequestWin* request)
578 {
579     KURL requestURL = request->frameLoadRequest().resourceRequest().url();
580     String jsString = scriptStringIfJavaScriptURL(requestURL);
581
582     if (jsString.isNull()) {
583         m_parentFrame->loader()->urlSelected(request->frameLoadRequest(), 0, true);
584
585         // FIXME: <rdar://problem/4807469> This should be sent when the document has finished loading
586         if (request->sendNotification()) {
587             KJS::JSLock::DropAllLocks dropAllLocks;
588             m_plugin->pluginFuncs()->urlnotify(m_instance, requestURL.url().utf8(), NPRES_DONE, request->notifyData());
589         }
590
591         return;
592     }
593
594     // Targeted JavaScript requests are only allowed on the frame that contains the JavaScript plugin
595     // and this has been made sure in ::load.
596     ASSERT(request->frameLoadRequest().frameName().isEmpty() || m_parentFrame->tree()->find(request->frameLoadRequest().frameName()) == m_parentFrame);
597     
598     // Executing a script can cause the plugin view to be destroyed, so we keep a reference to the parent frame.
599     RefPtr<Frame> parentFrame =  m_parentFrame;
600     JSValue* result = m_parentFrame->loader()->executeScript(0, jsString.deprecatedString(), true);
601     String resultString;
602
603     if (!getString(parentFrame->scriptProxy(), result, resultString))
604         return;
605
606     if (!request->frameLoadRequest().frameName().isNull()) {
607         parentFrame->loader()->begin();
608         parentFrame->loader()->write(resultString);
609         parentFrame->loader()->end();
610     } else {
611         CString cstr = resultString.utf8();
612         RefPtr<PluginStreamWin> stream = new PluginStreamWin(this, parentFrame.get(), request->frameLoadRequest().resourceRequest(), request->sendNotification(), request->notifyData());
613         m_streams.add(stream);
614         stream->sendJavaScriptStream(requestURL, cstr);
615     }
616 }
617
618 void PluginViewWin::requestTimerFired(Timer<PluginViewWin>* timer)
619 {
620     ASSERT(timer == &m_requestTimer);
621     ASSERT(m_requests.size() > 0);
622
623     PluginRequestWin* request = m_requests[0];
624     m_requests.remove(0);
625     
626     // Schedule a new request before calling performRequest since the call to
627     // performRequest can cause the plugin view to be deleted.
628     if (m_requests.size() > 0)
629         m_requestTimer.startOneShot(0);
630
631     performRequest(request);
632 }
633
634 void PluginViewWin::scheduleRequest(PluginRequestWin* request)
635 {
636     m_requests.append(request);
637     m_requestTimer.startOneShot(0);
638 }
639
640 NPError PluginViewWin::load(const FrameLoadRequest& frameLoadRequest, bool sendNotification, void* notifyData)
641 {
642     ASSERT(frameLoadRequest.resourceRequest().httpMethod() == "GET" || frameLoadRequest.resourceRequest().httpMethod() == "POST");
643
644     KURL url = frameLoadRequest.resourceRequest().url();
645     
646     if (!url.isValid())
647         return NPERR_INVALID_URL;
648
649     // FIXME: don't let a plugin start any loads if it is no longer part of a document that is being 
650     // displayed
651
652     String target = frameLoadRequest.frameName();
653     String jsString = scriptStringIfJavaScriptURL(url);
654     if (!jsString.isNull()) {
655         Settings* settings = m_parentFrame->settings();
656         if (!settings || !settings->isJavaScriptEnabled()) {
657             // Return NPERR_GENERIC_ERROR if JS is disabled. This is what Mozilla does.
658             return NPERR_GENERIC_ERROR;
659         } else if (target.isNull() && m_mode == NP_FULL) {
660             // Don't allow a JavaScript request from a standalone plug-in that is self-targetted
661             // because this can cause the user to be redirected to a blank page (3424039).
662             return NPERR_INVALID_PARAM;
663         }
664     }
665
666     if (!jsString.isNull() || !target.isNull()) {
667         if (!jsString.isNull() && !target.isNull() && m_parentFrame->tree()->find(target) != m_parentFrame) {
668             // For security reasons, only allow JS requests to be made on the frame that contains the plug-in.
669             return NPERR_INVALID_PARAM;
670         }
671
672         PluginRequestWin* request = new PluginRequestWin(frameLoadRequest, sendNotification, notifyData);
673         scheduleRequest(request);
674     } else {
675         PluginStreamWin* stream = new PluginStreamWin(this, m_parentFrame, frameLoadRequest.resourceRequest(), sendNotification, notifyData);
676         m_streams.add(stream);
677
678         stream->start();
679     }
680
681     return NPERR_NO_ERROR;
682 }
683
684 static KURL makeURL(const KURL& baseURL, const char* relativeURLString)
685 {
686     DeprecatedString urlString = DeprecatedString::fromLatin1(relativeURLString);
687
688     // Strip return characters
689     urlString.replace('\n', "");
690     urlString.replace('\r', "");
691
692     return KURL(baseURL, urlString);
693 }
694
695 NPError PluginViewWin::getURLNotify(const char* url, const char* target, void* notifyData)
696 {
697     FrameLoadRequest frameLoadRequest;
698
699     frameLoadRequest.setFrameName(target);
700     frameLoadRequest.resourceRequest().setHTTPMethod("GET");
701     frameLoadRequest.resourceRequest().setURL(makeURL(m_baseURL, url));
702
703     return load(frameLoadRequest, true, notifyData);
704 }
705
706 NPError PluginViewWin::getURL(const char* url, const char* target)
707 {
708     FrameLoadRequest frameLoadRequest;
709
710     frameLoadRequest.setFrameName(target);
711     frameLoadRequest.resourceRequest().setHTTPMethod("GET");
712     frameLoadRequest.resourceRequest().setURL(makeURL(m_baseURL, url));
713
714     return load(frameLoadRequest, false, 0);
715 }
716
717 static inline bool startsWithBlankLine(const Vector<char>& buffer)
718 {
719     return buffer.size() > 0 && buffer[0] == '\n';
720 }
721
722 static inline int locationAfterFirstBlankLine(const Vector<char>& buffer)
723 {
724     const char* bytes = buffer.data();
725     unsigned length = buffer.size();
726
727     for (unsigned i = 0; i < length - 4; i++) {
728         // Support for Acrobat. It sends "\n\n".
729         if (bytes[i] == '\n' && bytes[i + 1] == '\n')
730             return i + 2;
731         
732         // Returns the position after 2 CRLF's or 1 CRLF if it is the first line.
733         if (bytes[i] == '\r' && bytes[i + 1] == '\n') {
734             i += 2;
735             if (i == 2)
736                 return i;
737             else if (bytes[i] == '\n')
738                 // Support for Director. It sends "\r\n\n" (3880387).
739                 return i + 1;
740             else if (bytes[i] == '\r' && bytes[i + 1] == '\n')
741                 // Support for Flash. It sends "\r\n\r\n" (3758113).
742                 return i + 2;
743         }
744     }
745
746     return -1;
747 }
748
749 static inline const char* findEOL(const char* bytes, unsigned length)
750 {
751     // According to the HTTP specification EOL is defined as
752     // a CRLF pair. Unfortunately, some servers will use LF
753     // instead. Worse yet, some servers will use a combination
754     // of both (e.g. <header>CRLFLF<body>), so findEOL needs
755     // to be more forgiving. It will now accept CRLF, LF or
756     // CR.
757     //
758     // It returns NULL if EOLF is not found or it will return
759     // a pointer to the first terminating character.
760     for (unsigned i = 0; i < length; i++) {
761         if (bytes[i] == '\n')
762             return bytes + i;
763         if (bytes[i] == '\r') {
764             // Check to see if spanning buffer bounds
765             // (CRLF is across reads). If so, wait for
766             // next read.
767             if (i + 1 == length)
768                 break;
769
770             return bytes + i;
771         }
772     }
773
774     return 0;
775 }
776
777 static inline String capitalizeRFC822HeaderFieldName(const String& name)
778 {
779     bool capitalizeCharacter = true;
780     String result;
781
782     for (unsigned i = 0; i < name.length(); i++) {
783         UChar c;
784
785         if (capitalizeCharacter && name[i] >= 'a' && name[i] <= 'z')
786             c = toupper(name[i]);
787         else if (!capitalizeCharacter && name[i] >= 'A' && name[i] <= 'Z')
788             c = tolower(name[i]);
789         else
790             c = name[i];
791
792         if (name[i] == '-')
793             capitalizeCharacter = true;
794         else
795             capitalizeCharacter = false;
796
797         result.append(c);
798     }
799
800     return result;
801 }
802
803 static inline HTTPHeaderMap parseRFC822HeaderFields(const Vector<char>& buffer, unsigned length)
804 {
805     const char* bytes = buffer.data();
806     const char* eol;
807     String lastKey;
808     HTTPHeaderMap headerFields;
809
810     // Loop ove rlines until we're past the header, or we can't find any more end-of-lines
811     while ((eol = findEOL(bytes, length))) {
812         const char* line = bytes;
813         int lineLength = eol - bytes;
814         
815         // Move bytes to the character after the terminator as returned by findEOL.
816         bytes = eol + 1;
817         if ((*eol == '\r') && (*bytes == '\n'))
818             bytes++; // Safe since findEOL won't return a spanning CRLF.
819
820         length -= (bytes - line);
821         if (lineLength == 0)
822             // Blank line; we're at the end of the header
823             break;
824         else if (*line == ' ' || *line == '\t') {
825             // Continuation of the previous header
826             if (lastKey.isNull()) {
827                 // malformed header; ignore it and continue
828                 continue;
829             } else {
830                 // Merge the continuation of the previous header
831                 String currentValue = headerFields.get(lastKey);
832                 String newValue = DeprecatedString::fromLatin1(line, lineLength);
833
834                 headerFields.set(lastKey, currentValue + newValue);
835             }
836         } else {
837             // Brand new header
838             const char* colon;
839             for (colon = line; *colon != ':' && colon != eol; colon++) {
840                 // empty loop
841             }
842             if (colon == eol) 
843                 // malformed header; ignore it and continue
844                 continue;
845             else {
846                 lastKey = capitalizeRFC822HeaderFieldName(DeprecatedString::fromLatin1(line, colon - line));
847                 String value;
848
849                 for (colon++; colon != eol; colon++) {
850                     if (*colon != ' ' && *colon != '\t')
851                         break;
852                 }
853                 if (colon == eol)
854                     value = "";
855                 else
856                     value = DeprecatedString::fromLatin1(colon, eol - colon);
857
858                 String oldValue = headerFields.get(lastKey);
859                 if (!oldValue.isNull()) {
860                     String tmp = oldValue;
861                     tmp += ", ";
862                     tmp += value;
863                     value = tmp;
864                 }
865
866                 headerFields.set(lastKey, value);
867             }
868         }
869     }
870
871     return headerFields;
872 }
873
874 NPError PluginViewWin::handlePost(const char* url, const char* target, uint32 len, const char* buf, bool file, void* notifyData, bool sendNotification, bool allowHeaders)
875 {
876     if (!url || !len || !buf)
877         return NPERR_INVALID_PARAM;
878
879     FrameLoadRequest frameLoadRequest;
880
881     HTTPHeaderMap headerFields;
882     Vector<char> buffer;
883     
884     if (file) {
885         String filename = DeprecatedString::fromLatin1(buf, len);
886
887         if (filename.startsWith("file:///"))
888             filename = filename.substring(8);
889
890         // Get file info
891         WIN32_FILE_ATTRIBUTE_DATA attrs;
892         if (GetFileAttributesExW(filename.charactersWithNullTermination(), GetFileExInfoStandard, &attrs) == 0)
893             return NPERR_FILE_NOT_FOUND;
894
895         if (attrs.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
896             return NPERR_FILE_NOT_FOUND;
897
898         HANDLE fileHandle = CreateFileW(filename.charactersWithNullTermination(), FILE_READ_DATA, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
899         
900         if (fileHandle == INVALID_HANDLE_VALUE)
901             return NPERR_FILE_NOT_FOUND;
902
903         buffer.resize(attrs.nFileSizeLow);
904
905         DWORD bytesRead;
906         int retval = ReadFile(fileHandle, buffer.data(), attrs.nFileSizeLow, &bytesRead, 0);
907
908         CloseHandle(fileHandle);
909
910         if (retval == 0 || bytesRead != attrs.nFileSizeLow)
911             return NPERR_FILE_NOT_FOUND;
912     } else {
913         buffer.resize(len);
914         memcpy(buffer.data(), buf, len);
915     }
916
917     const char* postData = buffer.data();
918     int postDataLength = buffer.size();
919     
920     if (allowHeaders) {
921         if (startsWithBlankLine(buffer)) {
922             postData++;
923             postDataLength--;
924         } else {
925             int location = locationAfterFirstBlankLine(buffer);
926             if (location != -1) {
927                 // If the blank line is somewhere in the middle of the buffer, everything before is the header
928                 headerFields = parseRFC822HeaderFields(buffer, location);
929                 unsigned dataLength = buffer.size() - location;
930
931                 // Sometimes plugins like to set Content-Length themselves when they post,
932                 // but WebFoundation does not like that. So we will remove the header
933                 // and instead truncate the data to the requested length.
934                 String contentLength = headerFields.get("Content-Length");
935
936                 if (!contentLength.isNull())
937                     dataLength = min(contentLength.toInt(), (int)dataLength);
938                 headerFields.remove("Content-Length");
939
940                 postData += location;
941                 postDataLength = dataLength;
942             }
943         }
944     }
945
946     frameLoadRequest.resourceRequest().setHTTPMethod("POST");
947     frameLoadRequest.resourceRequest().setURL(makeURL(m_baseURL, url));
948     frameLoadRequest.resourceRequest().addHTTPHeaderFields(headerFields);
949     frameLoadRequest.resourceRequest().setHTTPBody(PassRefPtr<FormData>(new FormData(postData, postDataLength)));
950     frameLoadRequest.setFrameName(target);
951
952     return load(frameLoadRequest, sendNotification, notifyData);
953 }
954
955 NPError PluginViewWin::postURLNotify(const char* url, const char* target, uint32 len, const char* buf, NPBool file, void* notifyData)
956 {
957     return handlePost(url, target, len, buf, file, notifyData, true, true);
958 }
959
960 NPError PluginViewWin::postURL(const char* url, const char* target, uint32 len, const char* buf, NPBool file)
961 {
962     // As documented, only allow headers to be specified via NPP_PostURL when using a file.
963     return handlePost(url, target, len, buf, file, 0, false, file);
964 }
965
966 NPError PluginViewWin::newStream(NPMIMEType type, const char* target, NPStream** stream)
967 {
968     notImplemented();
969     // Unsupported
970     return NPERR_GENERIC_ERROR;
971 }
972
973 int32 PluginViewWin::write(NPStream* stream, int32 len, void* buffer)
974 {
975     notImplemented();
976     // Unsupported
977     return -1;
978 }
979
980 NPError PluginViewWin::destroyStream(NPStream* stream, NPReason reason)
981 {
982     PluginStreamWin* browserStream = static_cast<PluginStreamWin*>(stream->ndata);
983
984     if (!stream || PluginStreamWin::ownerForStream(stream) != m_instance)
985         return NPERR_INVALID_INSTANCE_ERROR;
986
987     browserStream->cancelAndDestroyStream(reason);
988     return NPERR_NO_ERROR;
989 }
990
991 const char* PluginViewWin::userAgent()
992 {
993     if (m_quirks & PluginQuirkWantsMozillaUserAgent)
994         return MozillaUserAgent;
995
996     if (m_userAgent.isNull())
997         m_userAgent = m_parentFrame->loader()->userAgent(m_url).utf8();
998     return m_userAgent;
999 }
1000
1001 void PluginViewWin::status(const char* message)
1002 {
1003     String s = DeprecatedString::fromLatin1(message);
1004
1005     if (Page* page = m_parentFrame->page())
1006         page->chrome()->setStatusbarText(m_parentFrame, s);
1007 }
1008
1009 NPError PluginViewWin::getValue(NPNVariable variable, void* value)
1010 {
1011     switch (variable) {
1012         case NPNVWindowNPObject: {
1013             NPObject* windowScriptObject = m_parentFrame->windowScriptNPObject();
1014
1015             // Return value is expected to be retained, as described here: <http://www.mozilla.org/projects/plugin/npruntime.html>
1016             if (windowScriptObject)
1017                 _NPN_RetainObject(windowScriptObject);
1018
1019             void** v = (void**)value;
1020             *v = windowScriptObject;
1021             
1022             return NPERR_NO_ERROR;
1023         }
1024
1025         case NPNVPluginElementNPObject: {
1026             NPObject* pluginScriptObject = 0;
1027
1028             if (m_element->hasTagName(appletTag) || m_element->hasTagName(embedTag) || m_element->hasTagName(objectTag))
1029                 pluginScriptObject = static_cast<HTMLPlugInElement*>(m_element)->getNPObject();
1030
1031             // Return value is expected to be retained, as described here: <http://www.mozilla.org/projects/plugin/npruntime.html>
1032             if (pluginScriptObject)
1033                 _NPN_RetainObject(pluginScriptObject);
1034
1035             void** v = (void**)value;
1036             *v = pluginScriptObject;
1037
1038             return NPERR_NO_ERROR;
1039         }
1040
1041         case NPNVnetscapeWindow: {
1042             HWND* w = reinterpret_cast<HWND*>(value);
1043
1044             *w = containingWindow();
1045
1046             return NPERR_NO_ERROR;
1047         }
1048         default:
1049             return NPERR_GENERIC_ERROR;
1050     }
1051 }
1052
1053 NPError PluginViewWin::setValue(NPPVariable variable, void* value)
1054 {
1055     switch (variable) {
1056         case NPPVpluginWindowBool:
1057             m_isWindowed = value;
1058             return NPERR_NO_ERROR;
1059         case NPPVpluginTransparentBool:
1060             m_isTransparent = value;
1061             return NPERR_NO_ERROR;
1062         default:
1063             notImplemented();
1064             return NPERR_GENERIC_ERROR;
1065     }
1066 }
1067
1068 void PluginViewWin::invalidateTimerFired(Timer<PluginViewWin>* timer)
1069 {
1070     ASSERT(timer == &m_invalidateTimer);
1071
1072     for (unsigned i = 0; i < m_invalidRects.size(); i++)
1073         Widget::invalidateRect(m_invalidRects[i]);
1074     m_invalidRects.clear();
1075 }
1076
1077
1078 void PluginViewWin::invalidateRect(NPRect* rect)
1079 {
1080     if (!rect) {
1081         invalidate();
1082         return;
1083     }
1084
1085     IntRect r(rect->left, rect->top, rect->right - rect->left, rect->bottom - rect->top);
1086
1087     if (m_isWindowed) {
1088         RECT invalidRect(r);
1089         InvalidateRect(m_window, &invalidRect, FALSE);
1090     } else {
1091         if (m_quirks & PluginQuirksThrottleInvalidate) {
1092             m_invalidRects.append(r);
1093             if (!m_invalidateTimer.isActive())
1094                 m_invalidateTimer.startOneShot(0.0);
1095         } else
1096             Widget::invalidateRect(r);
1097     }
1098 }
1099
1100 void PluginViewWin::invalidateRegion(NPRegion region)
1101 {
1102     if (m_isWindowed)
1103         return;
1104
1105     RECT r;
1106
1107     if (GetRgnBox(region, &r) == 0) {
1108         invalidate();
1109         return;
1110     }
1111
1112     Widget::invalidateRect(r);
1113 }
1114
1115 void PluginViewWin::forceRedraw()
1116 {
1117     if (m_isWindowed)
1118         ::UpdateWindow(m_window);
1119     else
1120         ::UpdateWindow(containingWindow());
1121 }
1122
1123 KJS::Bindings::Instance* PluginViewWin::bindingInstance()
1124 {
1125     NPObject* object = 0;
1126
1127     if (!m_plugin || !m_plugin->pluginFuncs()->getvalue)
1128         return 0;
1129
1130     NPError npErr;
1131     {
1132         KJS::JSLock::DropAllLocks dropAllLocks;
1133         npErr = m_plugin->pluginFuncs()->getvalue(m_instance, NPPVpluginScriptableNPObject, &object);
1134     }
1135
1136     if (npErr != NPERR_NO_ERROR || !object)
1137         return 0;
1138
1139     RefPtr<KJS::Bindings::RootObject> root = m_parentFrame->createRootObject(this, m_parentFrame->scriptProxy()->interpreter());
1140     KJS::Bindings::Instance *instance = KJS::Bindings::Instance::createBindingForLanguageInstance(KJS::Bindings::Instance::CLanguage, object, root.release());
1141
1142     _NPN_ReleaseObject(object);
1143
1144     return instance;
1145 }
1146
1147 PluginViewWin::~PluginViewWin()
1148 {
1149     stop();
1150
1151     deleteAllValues(m_requests);
1152
1153     freeStringArray(m_paramNames, m_paramCount);
1154     freeStringArray(m_paramValues, m_paramCount);
1155
1156     if (m_window)
1157         DestroyWindow(m_window);
1158
1159     m_parentFrame->cleanupScriptObjectsForPlugin(this);
1160     m_plugin->unload();
1161 }
1162
1163 void PluginViewWin::disconnectStream(PluginStreamWin* stream)
1164 {
1165     ASSERT(m_streams.contains(stream));
1166
1167     m_streams.remove(stream);
1168 }
1169
1170 void PluginViewWin::determineQuirks(const String& mimeType)
1171 {
1172     // The flash plugin only requests windowless plugins if we return a mozilla user agent
1173     if (mimeType == "application/x-shockwave-flash") {
1174         m_quirks |= PluginQuirkWantsMozillaUserAgent;
1175         m_quirks |= PluginQuirksThrottleInvalidate;
1176     }
1177
1178     // The WMP plugin sets its size on the first NPP_SetWindow call and never updates its size, so
1179     // call SetWindow when the plugin view has a correct size
1180     if (m_plugin->name().contains("Microsoft") && m_plugin->name().contains("Windows Media"))
1181         m_quirks |= PluginQuirkDeferFirstSetWindowCall;
1182
1183     // Shockwave calls SetWindowLongA to set a new WNDPROC on its plugin window. The value returned from SetWindowLongA is the old WNDPROC.
1184     // If the previous WNDPROC was an Unicode WNDPROC, the address of the WNDPROC will not be returned. Instead, a special
1185     // value that indicates that the messages coming to the WNDPROC need to be translated to Unicode. If CallWndProc is used to 
1186     // call the WNDPROC, it knows when the value is a real function pointer or not. If it's not, the message should be translated.
1187     // The Shockwave plugin however blindly treats the WNDPROC as a function pointer and tries to call it. Because of this, we set an ASCII
1188     // WNDPROC on the plugin window so that the value returned to Shockwave will be a real function pointer.
1189     // For more info on this, see http://blogs.msdn.com/oldnewthing/archive/2003/12/01/55900.aspx
1190     if (mimeType == "application/x-director")
1191         m_quirks |= PluginQuirksWantsAsciiWindowProc;
1192 }
1193
1194 PluginViewWin::PluginViewWin(Frame* parentFrame, PluginPackageWin* plugin, Element* element, const KURL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType)
1195     : m_parentFrame(parentFrame)
1196     , m_plugin(plugin)
1197     , m_element(element)
1198     , m_isStarted(false)
1199     , m_url(url)
1200     , m_baseURL(m_parentFrame->loader()->completeURL(m_parentFrame->document()->baseURL()))
1201     , m_status(PluginStatusLoadedSuccessfully)
1202     , m_requestTimer(this, &PluginViewWin::requestTimerFired)
1203     , m_invalidateTimer(this, &PluginViewWin::invalidateTimerFired)
1204     , m_paramNames(0)
1205     , m_paramValues(0)
1206     , m_window(0)
1207     , m_quirks(0)
1208     , m_isWindowed(true)
1209     , m_isTransparent(false)
1210     , m_isVisible(false)
1211     , m_haveInitialized(false)
1212 {
1213     if (!m_plugin) {
1214         m_status = PluginStatusCanNotFindPlugin;
1215         return;
1216     }
1217
1218     m_instance = &m_instanceStruct;
1219     m_instance->ndata = this;
1220
1221     m_mimeType = mimeType.utf8();
1222
1223     m_paramCount = paramNames.size();
1224     m_paramNames = createUTF8StringArray(paramNames);
1225     m_paramValues = createUTF8StringArray(paramValues);
1226
1227     m_mode = element->document()->isPluginDocument() ? NP_FULL : NP_EMBED;
1228
1229     determineQuirks(mimeType);
1230 }
1231
1232 void PluginViewWin::init()
1233 {
1234     if (m_haveInitialized)
1235         return;
1236     m_haveInitialized = true;
1237
1238     if (!m_plugin) {
1239         ASSERT(m_status == PluginStatusCanNotFindPlugin);
1240         return;
1241     }
1242
1243     if (!m_plugin->load()) {
1244         m_plugin = 0;
1245         m_status = PluginStatusCanNotLoadPlugin;
1246         return;
1247     }
1248
1249     if (!start()) {
1250         m_status = PluginStatusCanNotLoadPlugin;
1251         return;
1252     }
1253
1254     if (m_isWindowed) {
1255         registerPluginView();
1256
1257         DWORD flags = WS_CHILD;
1258         if (m_isVisible)
1259             flags |= WS_VISIBLE;
1260
1261         m_window = CreateWindowEx(0, kWebPluginViewWindowClassName, 0, flags,
1262                                   0, 0, 0, 0, m_parentFrame->view()->containingWindow(), 0, Page::instanceHandle(), 0);
1263
1264         if (m_quirks & PluginQuirksWantsAsciiWindowProc)
1265             ::SetWindowLongPtrA(m_window, GWL_WNDPROC, (LONG)PluginViewWndProc);
1266
1267         SetProp(m_window, kWebPluginViewProperty, this);
1268
1269         m_npWindow.type = NPWindowTypeWindow;
1270         m_npWindow.window = m_window;
1271     } else {
1272         m_npWindow.type = NPWindowTypeDrawable;
1273         m_npWindow.window = 0;
1274     }
1275
1276     if (!(m_quirks & PluginQuirkDeferFirstSetWindowCall))
1277         setNPWindowRect(frameGeometry());
1278
1279     m_status = PluginStatusLoadedSuccessfully;
1280 }
1281
1282 } // namespace WebCore