2008-11-12 Tor Arne Vestbø <tavestbo@trolltech.com>
[WebKit-https.git] / WebCore / plugins / PluginView.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
3  * Copyright (C) 2008 Collabora Ltd. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #include "config.h"
28 #include "PluginView.h"
29
30 #include "Document.h"
31 #include "DocumentLoader.h"
32 #include "Element.h"
33 #include "FrameLoader.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 "JSDOMWindow.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 #if PLATFORM(WIN_OS) && !PLATFORM(WX) && ENABLE(NETSCAPE_PLUGIN_API)
50 #include "PluginMessageThrottlerWin.h"
51 #endif
52 #include "PluginPackage.h"
53 #include "JSDOMBinding.h"
54 #include "ScriptController.h"
55 #include "PluginDatabase.h"
56 #include "PluginDebug.h"
57 #include "PluginMainThreadScheduler.h"
58 #include "PluginPackage.h"
59 #include "RenderObject.h"
60 #include "c_instance.h"
61 #include "npruntime_impl.h"
62 #include "runtime_root.h"
63 #include "Settings.h"
64 #include "runtime.h"
65 #include <runtime/JSLock.h>
66 #include <runtime/JSValue.h>
67 #include <wtf/ASCIICType.h>
68
69 using JSC::ExecState;
70 using JSC::JSLock;
71 using JSC::JSObject;
72 using JSC::JSValue;
73 using JSC::UString;
74
75 using std::min;
76
77 using namespace WTF;
78
79 namespace WebCore {
80
81 using namespace HTMLNames;
82
83 static int s_callingPlugin;
84
85 static String scriptStringIfJavaScriptURL(const KURL& url)
86 {
87     if (!url.protocolIs("javascript"))
88         return String();
89
90     // This returns an unescaped string
91     return decodeURLEscapeSequences(url.string().substring(11));
92 }
93
94 PluginView* PluginView::s_currentPluginView = 0;
95
96 void PluginView::popPopupsStateTimerFired(Timer<PluginView>*)
97 {
98     popPopupsEnabledState();
99 }
100
101 IntRect PluginView::windowClipRect() const
102 {
103     // Start by clipping to our bounds.
104     IntRect clipRect(m_windowRect);
105     
106     // Take our element and get the clip rect from the enclosing layer and frame view.
107     RenderLayer* layer = m_element->renderer()->enclosingLayer();
108     FrameView* parentView = m_element->document()->view();
109     clipRect.intersect(parentView->windowClipRectForLayer(layer, true));
110
111     return clipRect;
112 }
113
114 void PluginView::setFrameRect(const IntRect& rect)
115 {
116     if (m_element->document()->printing())
117         return;
118
119     if (rect != frameRect())
120         Widget::setFrameRect(rect);
121
122     updatePluginWidget();
123
124 #if PLATFORM(WIN_OS)
125     // On Windows, always call plugin to change geometry.
126     setNPWindowRect(rect);
127 #elif XP_UNIX
128     // On Unix, only call plugin if it's full-page.
129     if (m_mode == NP_FULL)
130         setNPWindowRect(rect);
131 #endif
132 }
133
134 void PluginView::frameRectsChanged() const
135 {
136     updatePluginWidget();
137 }
138
139 void PluginView::handleEvent(Event* event)
140 {
141     if (!m_plugin || m_isWindowed)
142         return;
143
144     if (event->isMouseEvent())
145         handleMouseEvent(static_cast<MouseEvent*>(event));
146     else if (event->isKeyboardEvent())
147         handleKeyboardEvent(static_cast<KeyboardEvent*>(event));
148 }
149
150 bool PluginView::start()
151 {
152     if (m_isStarted)
153         return false;
154
155     PluginMainThreadScheduler::scheduler().registerPlugin(m_instance);
156
157     ASSERT(m_plugin);
158     ASSERT(m_plugin->pluginFuncs()->newp);
159
160     NPError npErr;
161     {
162         PluginView::setCurrentPluginView(this);
163         JSC::JSLock::DropAllLocks dropAllLocks(false);
164         setCallingPlugin(true);
165         npErr = m_plugin->pluginFuncs()->newp((NPMIMEType)m_mimeType.data(), m_instance, m_mode, m_paramCount, m_paramNames, m_paramValues, NULL);
166         setCallingPlugin(false);
167         LOG_NPERROR(npErr);
168         PluginView::setCurrentPluginView(0);
169     }
170
171     if (npErr != NPERR_NO_ERROR)
172         return false;
173
174     m_isStarted = true;
175
176     if (!m_url.isEmpty() && !m_loadManually) {
177         FrameLoadRequest frameLoadRequest;
178         frameLoadRequest.resourceRequest().setHTTPMethod("GET");
179         frameLoadRequest.resourceRequest().setURL(m_url);
180         load(frameLoadRequest, false, 0);
181     }
182
183     return true;
184 }
185
186 void PluginView::setCurrentPluginView(PluginView* pluginView)
187 {
188     s_currentPluginView = pluginView;
189 }
190
191 PluginView* PluginView::currentPluginView()
192 {
193     return s_currentPluginView;
194 }
195
196 static char* createUTF8String(const String& str)
197 {
198     CString cstr = str.utf8();
199     char* result = reinterpret_cast<char*>(fastMalloc(cstr.length() + 1));
200
201     strncpy(result, cstr.data(), cstr.length() + 1);
202
203     return result;
204 }
205
206 static bool getString(ScriptController* proxy, JSValue* result, String& string)
207 {
208     if (!proxy || !result || result->isUndefined())
209         return false;
210     JSLock lock(false);
211
212     ExecState* exec = proxy->globalObject()->globalExec();
213     UString ustring = result->toString(exec);
214     exec->clearException();
215
216     string = ustring;
217     return true;
218 }
219
220 void PluginView::performRequest(PluginRequest* request)
221 {
222     // don't let a plugin start any loads if it is no longer part of a document that is being 
223     // displayed unless the loads are in the same frame as the plugin.
224     const String& targetFrameName = request->frameLoadRequest().frameName();
225     if (m_parentFrame->loader()->documentLoader() != m_parentFrame->loader()->activeDocumentLoader() &&
226         (targetFrameName.isNull() || m_parentFrame->tree()->find(targetFrameName) != m_parentFrame))
227         return;
228
229     KURL requestURL = request->frameLoadRequest().resourceRequest().url();
230     String jsString = scriptStringIfJavaScriptURL(requestURL);
231
232     if (jsString.isNull()) {
233         // if this is not a targeted request, create a stream for it. otherwise,
234         // just pass it off to the loader
235         if (targetFrameName.isEmpty()) {
236             RefPtr<PluginStream> stream = PluginStream::create(this, m_parentFrame, request->frameLoadRequest().resourceRequest(), request->sendNotification(), request->notifyData(), plugin()->pluginFuncs(), instance(), m_plugin->quirks());
237             m_streams.add(stream);
238             stream->start();
239         } else {
240             m_parentFrame->loader()->load(request->frameLoadRequest().resourceRequest(), targetFrameName);
241       
242             // FIXME: <rdar://problem/4807469> This should be sent when the document has finished loading
243             if (request->sendNotification()) {
244                 PluginView::setCurrentPluginView(this);
245                 JSC::JSLock::DropAllLocks dropAllLocks(false);
246                 setCallingPlugin(true);
247                 m_plugin->pluginFuncs()->urlnotify(m_instance, requestURL.string().utf8().data(), NPRES_DONE, request->notifyData());
248                 setCallingPlugin(false);
249                 PluginView::setCurrentPluginView(0);
250             }
251         }
252         return;
253     }
254
255     // Targeted JavaScript requests are only allowed on the frame that contains the JavaScript plugin
256     // and this has been made sure in ::load.
257     ASSERT(targetFrameName.isEmpty() || m_parentFrame->tree()->find(targetFrameName) == m_parentFrame);
258     
259     // Executing a script can cause the plugin view to be destroyed, so we keep a reference to the parent frame.
260     RefPtr<Frame> parentFrame = m_parentFrame;
261     JSValue* result = m_parentFrame->loader()->executeScript(jsString, request->shouldAllowPopups());
262
263     if (targetFrameName.isNull()) {
264         String resultString;
265
266         CString cstr;
267         if (getString(parentFrame->script(), result, resultString))
268             cstr = resultString.utf8();
269
270         RefPtr<PluginStream> stream = PluginStream::create(this, m_parentFrame, request->frameLoadRequest().resourceRequest(), request->sendNotification(), request->notifyData(), plugin()->pluginFuncs(), instance(), m_plugin->quirks());
271         m_streams.add(stream);
272         stream->sendJavaScriptStream(requestURL, cstr);
273     }
274 }
275
276 void PluginView::requestTimerFired(Timer<PluginView>* timer)
277 {
278     ASSERT(timer == &m_requestTimer);
279     ASSERT(m_requests.size() > 0);
280     ASSERT(!m_isJavaScriptPaused);
281
282     PluginRequest* request = m_requests[0];
283     m_requests.remove(0);
284     
285     // Schedule a new request before calling performRequest since the call to
286     // performRequest can cause the plugin view to be deleted.
287     if (m_requests.size() > 0)
288         m_requestTimer.startOneShot(0);
289
290     performRequest(request);
291     delete request;
292 }
293
294 void PluginView::scheduleRequest(PluginRequest* request)
295 {
296     m_requests.append(request);
297
298     if (!m_isJavaScriptPaused)
299         m_requestTimer.startOneShot(0);
300 }
301
302 NPError PluginView::load(const FrameLoadRequest& frameLoadRequest, bool sendNotification, void* notifyData)
303 {
304     ASSERT(frameLoadRequest.resourceRequest().httpMethod() == "GET" || frameLoadRequest.resourceRequest().httpMethod() == "POST");
305
306     KURL url = frameLoadRequest.resourceRequest().url();
307     
308     if (url.isEmpty())
309         return NPERR_INVALID_URL;
310
311     // Don't allow requests to be made when the document loader is stopping all loaders.
312     if (m_parentFrame->loader()->documentLoader()->isStopping())
313         return NPERR_GENERIC_ERROR;
314
315     const String& targetFrameName = frameLoadRequest.frameName();
316     String jsString = scriptStringIfJavaScriptURL(url);
317
318     if (!jsString.isNull()) {
319         Settings* settings = m_parentFrame->settings();
320
321         // Return NPERR_GENERIC_ERROR if JS is disabled. This is what Mozilla does.
322         if (!settings || !settings->isJavaScriptEnabled())
323             return NPERR_GENERIC_ERROR;
324         
325         // For security reasons, only allow JS requests to be made on the frame that contains the plug-in.
326         if (!targetFrameName.isNull() && m_parentFrame->tree()->find(targetFrameName) != m_parentFrame)
327             return NPERR_INVALID_PARAM;
328     } else if (!FrameLoader::canLoad(url, String(), m_parentFrame->document())) {
329             return NPERR_GENERIC_ERROR;
330     }
331
332     PluginRequest* request = new PluginRequest(frameLoadRequest, sendNotification, notifyData, arePopupsAllowed());
333     scheduleRequest(request);
334
335     return NPERR_NO_ERROR;
336 }
337
338 static KURL makeURL(const KURL& baseURL, const char* relativeURLString)
339 {
340     String urlString = relativeURLString;
341
342     // Strip return characters.
343     urlString.replace('\n', "");
344     urlString.replace('\r', "");
345
346     return KURL(baseURL, urlString);
347 }
348
349 NPError PluginView::getURLNotify(const char* url, const char* target, void* notifyData)
350 {
351     FrameLoadRequest frameLoadRequest;
352
353     frameLoadRequest.setFrameName(target);
354     frameLoadRequest.resourceRequest().setHTTPMethod("GET");
355     frameLoadRequest.resourceRequest().setURL(makeURL(m_baseURL, url));
356
357     return load(frameLoadRequest, true, notifyData);
358 }
359
360 NPError PluginView::getURL(const char* url, const char* target)
361 {
362     FrameLoadRequest frameLoadRequest;
363
364     frameLoadRequest.setFrameName(target);
365     frameLoadRequest.resourceRequest().setHTTPMethod("GET");
366     frameLoadRequest.resourceRequest().setURL(makeURL(m_baseURL, url));
367
368     return load(frameLoadRequest, false, 0);
369 }
370
371 NPError PluginView::postURLNotify(const char* url, const char* target, uint32 len, const char* buf, NPBool file, void* notifyData)
372 {
373     return handlePost(url, target, len, buf, file, notifyData, true, true);
374 }
375
376 NPError PluginView::postURL(const char* url, const char* target, uint32 len, const char* buf, NPBool file)
377 {
378     // As documented, only allow headers to be specified via NPP_PostURL when using a file.
379     return handlePost(url, target, len, buf, file, 0, false, file);
380 }
381
382 NPError PluginView::newStream(NPMIMEType type, const char* target, NPStream** stream)
383 {
384     notImplemented();
385     // Unsupported
386     return NPERR_GENERIC_ERROR;
387 }
388
389 int32 PluginView::write(NPStream* stream, int32 len, void* buffer)
390 {
391     notImplemented();
392     // Unsupported
393     return -1;
394 }
395
396 NPError PluginView::destroyStream(NPStream* stream, NPReason reason)
397 {
398     PluginStream* browserStream = static_cast<PluginStream*>(stream->ndata);
399
400     if (!stream || PluginStream::ownerForStream(stream) != m_instance)
401         return NPERR_INVALID_INSTANCE_ERROR;
402
403     browserStream->cancelAndDestroyStream(reason);
404     return NPERR_NO_ERROR;
405 }
406
407 void PluginView::status(const char* message)
408 {
409     if (Page* page = m_parentFrame->page())
410         page->chrome()->setStatusbarText(m_parentFrame, String(message));
411 }
412
413 NPError PluginView::setValue(NPPVariable variable, void* value)
414 {
415     switch (variable) {
416     case NPPVpluginWindowBool:
417         m_isWindowed = value;
418         return NPERR_NO_ERROR;
419     case NPPVpluginTransparentBool:
420         m_isTransparent = value;
421         return NPERR_NO_ERROR;
422 #if defined(XP_MACOSX)
423     case NPPVpluginDrawingModel:
424         return NPERR_NO_ERROR;
425     case NPPVpluginEventModel:
426         return NPERR_NO_ERROR;
427 #endif
428     default:
429         notImplemented();
430         return NPERR_GENERIC_ERROR;
431     }
432 }
433
434 void PluginView::invalidateTimerFired(Timer<PluginView>* timer)
435 {
436     ASSERT(timer == &m_invalidateTimer);
437
438     for (unsigned i = 0; i < m_invalidRects.size(); i++)
439         invalidateRect(m_invalidRects[i]);
440     m_invalidRects.clear();
441 }
442
443
444 void PluginView::pushPopupsEnabledState(bool state)
445 {
446     m_popupStateStack.append(state);
447 }
448  
449 void PluginView::popPopupsEnabledState()
450 {
451     m_popupStateStack.removeLast();
452 }
453
454 bool PluginView::arePopupsAllowed() const
455 {
456     if (!m_popupStateStack.isEmpty())
457         return m_popupStateStack.last();
458
459     return false;
460 }
461
462 void PluginView::setJavaScriptPaused(bool paused)
463 {
464     if (m_isJavaScriptPaused == paused)
465         return;
466     m_isJavaScriptPaused = paused;
467
468     if (m_isJavaScriptPaused)
469         m_requestTimer.stop();
470     else if (!m_requests.isEmpty())
471         m_requestTimer.startOneShot(0);
472 }
473
474 PassRefPtr<JSC::Bindings::Instance> PluginView::bindingInstance()
475 {
476 #if ENABLE(NETSCAPE_PLUGIN_API)
477     NPObject* object = 0;
478
479     if (!m_plugin || !m_plugin->pluginFuncs()->getvalue)
480         return 0;
481
482     NPError npErr;
483     {
484         PluginView::setCurrentPluginView(this);
485         JSC::JSLock::DropAllLocks dropAllLocks(false);
486         setCallingPlugin(true);
487         npErr = m_plugin->pluginFuncs()->getvalue(m_instance, NPPVpluginScriptableNPObject, &object);
488         setCallingPlugin(false);
489         PluginView::setCurrentPluginView(0);
490     }
491
492     if (npErr != NPERR_NO_ERROR || !object)
493         return 0;
494
495     RefPtr<JSC::Bindings::RootObject> root = m_parentFrame->script()->createRootObject(this);
496     RefPtr<JSC::Bindings::Instance> instance = JSC::Bindings::CInstance::create(object, root.release());
497
498     _NPN_ReleaseObject(object);
499
500     return instance.release();
501 #else
502     return 0;
503 #endif
504 }
505
506 void PluginView::disconnectStream(PluginStream* stream)
507 {
508     ASSERT(m_streams.contains(stream));
509
510     m_streams.remove(stream);
511 }
512
513 void PluginView::setParameters(const Vector<String>& paramNames, const Vector<String>& paramValues)
514 {
515     ASSERT(paramNames.size() == paramValues.size());
516
517     unsigned size = paramNames.size();
518     unsigned paramCount = 0;
519
520     m_paramNames = reinterpret_cast<char**>(fastMalloc(sizeof(char*) * size));
521     m_paramValues = reinterpret_cast<char**>(fastMalloc(sizeof(char*) * size));
522
523     for (unsigned i = 0; i < size; i++) {
524         if (m_plugin->quirks().contains(PluginQuirkRemoveWindowlessVideoParam) && equalIgnoringCase(paramNames[i], "windowlessvideo"))
525             continue;
526
527         m_paramNames[paramCount] = createUTF8String(paramNames[i]);
528         m_paramValues[paramCount] = createUTF8String(paramValues[i]);
529
530         paramCount++;
531     }
532
533     m_paramCount = paramCount;
534 }
535
536 PluginView::PluginView(Frame* parentFrame, const IntSize& size, PluginPackage* plugin, Element* element, const KURL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
537     : m_parentFrame(parentFrame)
538     , m_plugin(plugin)
539     , m_element(element)
540     , m_isStarted(false)
541     , m_url(url)
542     , m_baseURL(m_parentFrame->loader()->completeURL(m_parentFrame->document()->baseURL().string()))
543     , m_status(PluginStatusLoadedSuccessfully)
544     , m_requestTimer(this, &PluginView::requestTimerFired)
545     , m_invalidateTimer(this, &PluginView::invalidateTimerFired)
546     , m_popPopupsStateTimer(this, &PluginView::popPopupsStateTimerFired)
547     , m_paramNames(0)
548     , m_paramValues(0)
549 #if defined(XP_MACOSX)
550     , m_isWindowed(false)
551 #else
552     , m_isWindowed(true)
553 #endif
554     , m_isTransparent(false)
555     , m_haveInitialized(false)
556 #if PLATFORM(GTK) || defined(Q_WS_X11)
557     , m_needsXEmbed(false)
558 #endif
559 #if PLATFORM(QT)
560     , m_isNPAPIPlugin(false)
561 #endif
562 #if PLATFORM(WIN_OS) && !PLATFORM(WX) && ENABLE(NETSCAPE_PLUGIN_API)
563     , m_pluginWndProc(0)
564     , m_lastMessage(0)
565     , m_isCallingPluginWndProc(false)
566 #endif
567 #if (PLATFORM(QT) && PLATFORM(WIN_OS)) || defined(XP_MACOSX)
568     , m_window(0)
569 #endif
570     , m_loadManually(loadManually)
571     , m_manualStream(0)
572     , m_isJavaScriptPaused(false)
573 {
574     if (!m_plugin) {
575         m_status = PluginStatusCanNotFindPlugin;
576         return;
577     }
578
579     m_instance = &m_instanceStruct;
580     m_instance->ndata = this;
581     m_instance->pdata = 0;
582
583     m_mimeType = mimeType.utf8();
584
585     setParameters(paramNames, paramValues);
586
587 #ifdef XP_UNIX
588     m_npWindow.ws_info = 0;
589 #endif
590
591     m_mode = m_loadManually ? NP_FULL : NP_EMBED;
592
593     resize(size);
594 }
595
596 void PluginView::didReceiveResponse(const ResourceResponse& response)
597 {
598     ASSERT(m_loadManually);
599     ASSERT(!m_manualStream);
600
601     m_manualStream = PluginStream::create(this, m_parentFrame, m_parentFrame->loader()->activeDocumentLoader()->request(), false, 0, plugin()->pluginFuncs(), instance(), m_plugin->quirks());
602     m_manualStream->setLoadManually(true);
603
604     m_manualStream->didReceiveResponse(0, response);
605 }
606
607 void PluginView::didReceiveData(const char* data, int length)
608 {
609     ASSERT(m_loadManually);
610     ASSERT(m_manualStream);
611     
612     m_manualStream->didReceiveData(0, data, length);
613 }
614
615 void PluginView::didFinishLoading()
616 {
617     ASSERT(m_loadManually);
618     ASSERT(m_manualStream);
619
620     m_manualStream->didFinishLoading(0);
621 }
622
623 void PluginView::didFail(const ResourceError& error)
624 {
625     ASSERT(m_loadManually);
626     ASSERT(m_manualStream);
627
628     m_manualStream->didFail(0, error);
629 }
630
631 void PluginView::setCallingPlugin(bool b) const
632 {
633     if (!m_plugin->quirks().contains(PluginQuirkHasModalMessageLoop))
634         return;
635
636     if (b)
637         ++s_callingPlugin;
638     else
639         --s_callingPlugin;
640
641     ASSERT(s_callingPlugin >= 0);
642 }
643
644 bool PluginView::isCallingPlugin()
645 {
646     return s_callingPlugin > 0;
647 }
648
649 PluginView* PluginView::create(Frame* parentFrame, const IntSize& size, Element* element, const KURL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
650 {
651     // if we fail to find a plugin for this MIME type, findPlugin will search for
652     // a plugin by the file extension and update the MIME type, so pass a mutable String
653     String mimeTypeCopy = mimeType;
654     PluginPackage* plugin = PluginDatabase::installedPlugins()->findPlugin(url, mimeTypeCopy);
655
656     // No plugin was found, try refreshing the database and searching again
657     if (!plugin && PluginDatabase::installedPlugins()->refresh()) {
658         mimeTypeCopy = mimeType;
659         plugin = PluginDatabase::installedPlugins()->findPlugin(url, mimeTypeCopy);
660     }
661
662     return new PluginView(parentFrame, size, plugin, element, url, paramNames, paramValues, mimeTypeCopy, loadManually);
663 }
664
665 void PluginView::freeStringArray(char** stringArray, int length)
666 {
667     if (!stringArray)
668         return;
669
670     for (int i = 0; i < length; i++)
671         fastFree(stringArray[i]);
672
673     fastFree(stringArray);
674 }
675
676 static inline bool startsWithBlankLine(const Vector<char>& buffer)
677 {
678     return buffer.size() > 0 && buffer[0] == '\n';
679 }
680
681 static inline int locationAfterFirstBlankLine(const Vector<char>& buffer)
682 {
683     const char* bytes = buffer.data();
684     unsigned length = buffer.size();
685
686     for (unsigned i = 0; i < length - 4; i++) {
687         // Support for Acrobat. It sends "\n\n".
688         if (bytes[i] == '\n' && bytes[i + 1] == '\n')
689             return i + 2;
690         
691         // Returns the position after 2 CRLF's or 1 CRLF if it is the first line.
692         if (bytes[i] == '\r' && bytes[i + 1] == '\n') {
693             i += 2;
694             if (i == 2)
695                 return i;
696             else if (bytes[i] == '\n')
697                 // Support for Director. It sends "\r\n\n" (3880387).
698                 return i + 1;
699             else if (bytes[i] == '\r' && bytes[i + 1] == '\n')
700                 // Support for Flash. It sends "\r\n\r\n" (3758113).
701                 return i + 2;
702         }
703     }
704
705     return -1;
706 }
707
708 static inline const char* findEOL(const char* bytes, unsigned length)
709 {
710     // According to the HTTP specification EOL is defined as
711     // a CRLF pair. Unfortunately, some servers will use LF
712     // instead. Worse yet, some servers will use a combination
713     // of both (e.g. <header>CRLFLF<body>), so findEOL needs
714     // to be more forgiving. It will now accept CRLF, LF or
715     // CR.
716     //
717     // It returns NULL if EOLF is not found or it will return
718     // a pointer to the first terminating character.
719     for (unsigned i = 0; i < length; i++) {
720         if (bytes[i] == '\n')
721             return bytes + i;
722         if (bytes[i] == '\r') {
723             // Check to see if spanning buffer bounds
724             // (CRLF is across reads). If so, wait for
725             // next read.
726             if (i + 1 == length)
727                 break;
728
729             return bytes + i;
730         }
731     }
732
733     return 0;
734 }
735
736 static inline String capitalizeRFC822HeaderFieldName(const String& name)
737 {
738     bool capitalizeCharacter = true;
739     String result;
740
741     for (unsigned i = 0; i < name.length(); i++) {
742         UChar c;
743
744         if (capitalizeCharacter && name[i] >= 'a' && name[i] <= 'z')
745             c = toASCIIUpper(name[i]);
746         else if (!capitalizeCharacter && name[i] >= 'A' && name[i] <= 'Z')
747             c = toASCIILower(name[i]);
748         else
749             c = name[i];
750
751         if (name[i] == '-')
752             capitalizeCharacter = true;
753         else
754             capitalizeCharacter = false;
755
756         result.append(c);
757     }
758
759     return result;
760 }
761
762 static inline HTTPHeaderMap parseRFC822HeaderFields(const Vector<char>& buffer, unsigned length)
763 {
764     const char* bytes = buffer.data();
765     const char* eol;
766     String lastKey;
767     HTTPHeaderMap headerFields;
768
769     // Loop ove rlines until we're past the header, or we can't find any more end-of-lines
770     while ((eol = findEOL(bytes, length))) {
771         const char* line = bytes;
772         int lineLength = eol - bytes;
773         
774         // Move bytes to the character after the terminator as returned by findEOL.
775         bytes = eol + 1;
776         if ((*eol == '\r') && (*bytes == '\n'))
777             bytes++; // Safe since findEOL won't return a spanning CRLF.
778
779         length -= (bytes - line);
780         if (lineLength == 0)
781             // Blank line; we're at the end of the header
782             break;
783         else if (*line == ' ' || *line == '\t') {
784             // Continuation of the previous header
785             if (lastKey.isNull()) {
786                 // malformed header; ignore it and continue
787                 continue;
788             } else {
789                 // Merge the continuation of the previous header
790                 String currentValue = headerFields.get(lastKey);
791                 String newValue(line, lineLength);
792
793                 headerFields.set(lastKey, currentValue + newValue);
794             }
795         } else {
796             // Brand new header
797             const char* colon;
798             for (colon = line; *colon != ':' && colon != eol; colon++) {
799                 // empty loop
800             }
801             if (colon == eol) 
802                 // malformed header; ignore it and continue
803                 continue;
804             else {
805                 lastKey = capitalizeRFC822HeaderFieldName(String(line, colon - line));
806                 String value;
807
808                 for (colon++; colon != eol; colon++) {
809                     if (*colon != ' ' && *colon != '\t')
810                         break;
811                 }
812                 if (colon == eol)
813                     value = "";
814                 else
815                     value = String(colon, eol - colon);
816
817                 String oldValue = headerFields.get(lastKey);
818                 if (!oldValue.isNull()) {
819                     String tmp = oldValue;
820                     tmp += ", ";
821                     tmp += value;
822                     value = tmp;
823                 }
824
825                 headerFields.set(lastKey, value);
826             }
827         }
828     }
829
830     return headerFields;
831 }
832
833 NPError PluginView::handlePost(const char* url, const char* target, uint32 len, const char* buf, bool file, void* notifyData, bool sendNotification, bool allowHeaders)
834 {
835     if (!url || !len || !buf)
836         return NPERR_INVALID_PARAM;
837
838     FrameLoadRequest frameLoadRequest;
839
840     HTTPHeaderMap headerFields;
841     Vector<char> buffer;
842     
843     if (file) {
844         NPError readResult = handlePostReadFile(buffer, len, buf);
845         if(readResult != NPERR_NO_ERROR)
846             return readResult;
847     } else {
848         buffer.resize(len);
849         memcpy(buffer.data(), buf, len);
850     }
851
852     const char* postData = buffer.data();
853     int postDataLength = buffer.size();
854
855     if (allowHeaders) {
856         if (startsWithBlankLine(buffer)) {
857             postData++;
858             postDataLength--;
859         } else {
860             int location = locationAfterFirstBlankLine(buffer);
861             if (location != -1) {
862                 // If the blank line is somewhere in the middle of the buffer, everything before is the header
863                 headerFields = parseRFC822HeaderFields(buffer, location);
864                 unsigned dataLength = buffer.size() - location;
865
866                 // Sometimes plugins like to set Content-Length themselves when they post,
867                 // but WebFoundation does not like that. So we will remove the header
868                 // and instead truncate the data to the requested length.
869                 String contentLength = headerFields.get("Content-Length");
870
871                 if (!contentLength.isNull())
872                     dataLength = min(contentLength.toInt(), (int)dataLength);
873                 headerFields.remove("Content-Length");
874
875                 postData += location;
876                 postDataLength = dataLength;
877             }
878         }
879     }
880
881     frameLoadRequest.resourceRequest().setHTTPMethod("POST");
882     frameLoadRequest.resourceRequest().setURL(makeURL(m_baseURL, url));
883     frameLoadRequest.resourceRequest().addHTTPHeaderFields(headerFields);
884     frameLoadRequest.resourceRequest().setHTTPBody(FormData::create(postData, postDataLength));
885     frameLoadRequest.setFrameName(target);
886
887     return load(frameLoadRequest, sendNotification, notifyData);
888 }
889
890 void PluginView::invalidateWindowlessPluginRect(const IntRect& rect)
891 {
892     if (!isVisible())
893         return;
894     
895     RenderObject* renderer = m_element->renderer();
896     if (!renderer)
897         return;
898     
899     IntRect dirtyRect = rect;
900     dirtyRect.move(renderer->borderLeft() + renderer->paddingLeft(), renderer->borderTop() + renderer->paddingTop());
901     renderer->repaintRectangle(dirtyRect);
902 }
903
904 } // namespace WebCore