Safari 4 cannot be used to update firmware on Linksys routers.
[WebKit-https.git] / WebKit / mac / Plugins / WebBaseNetscapePluginView.mm
1 /*
2  * Copyright (C) 2005, 2006, 2007, 2008 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  *
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  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission. 
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #if ENABLE(NETSCAPE_PLUGIN_API)
30
31 #import "WebBaseNetscapePluginView.h"
32
33 #import "WebFrameInternal.h"
34 #import "WebKitLogging.h"
35 #import "WebKitNSStringExtras.h"
36 #import "WebKitSystemInterface.h"
37 #import "WebPluginContainerCheck.h"
38 #import "WebNetscapeContainerCheckContextInfo.h"
39 #import "WebNSURLExtras.h"
40 #import "WebNSURLRequestExtras.h"
41 #import "WebView.h"
42 #import "WebViewInternal.h"
43
44 #import <WebCore/WebCoreObjCExtras.h>
45 #import <WebCore/AuthenticationMac.h>
46 #import <WebCore/Credential.h>
47 #import <WebCore/CredentialStorage.h>
48 #import <WebCore/CString.h>
49 #import <WebCore/Document.h>
50 #import <WebCore/Element.h>
51 #import <WebCore/Frame.h>
52 #import <WebCore/FrameLoader.h>
53 #import <WebCore/HTMLPlugInElement.h>
54 #import <WebCore/Page.h>
55 #import <WebCore/ProtectionSpace.h>
56 #import <WebCore/RenderView.h>
57 #import <WebKit/DOMPrivate.h>
58 #import <runtime/InitializeThreading.h>
59 #import <wtf/Assertions.h>
60
61 #define LoginWindowDidSwitchFromUserNotification    @"WebLoginWindowDidSwitchFromUserNotification"
62 #define LoginWindowDidSwitchToUserNotification      @"WebLoginWindowDidSwitchToUserNotification"
63
64 using namespace WebCore;
65
66 @implementation WebBaseNetscapePluginView
67
68 + (void)initialize
69 {
70     JSC::initializeThreading();
71 #ifndef BUILDING_ON_TIGER
72     WebCoreObjCFinalizeOnMainThread(self);
73 #endif
74     WKSendUserChangeNotifications();
75 }
76
77 - (id)initWithFrame:(NSRect)frame
78       pluginPackage:(WebNetscapePluginPackage *)pluginPackage
79                 URL:(NSURL *)URL
80             baseURL:(NSURL *)baseURL
81            MIMEType:(NSString *)MIME
82       attributeKeys:(NSArray *)keys
83     attributeValues:(NSArray *)values
84        loadManually:(BOOL)loadManually
85             element:(PassRefPtr<WebCore::HTMLPlugInElement>)element
86 {
87     self = [super initWithFrame:frame];
88     if (!self)
89         return nil;
90     
91     _pluginPackage = pluginPackage;
92     _element = element;
93     _sourceURL.adoptNS([URL copy]);
94     _baseURL.adoptNS([baseURL copy]);
95     _MIMEType.adoptNS([MIME copy]);
96     
97 #if !defined(BUILDING_ON_TIGER) && !defined(BUILDING_ON_LEOPARD)
98     // Enable "kiosk mode" when instantiating the QT plug-in inside of Dashboard. See <rdar://problem/6878105>
99     if ([[[NSBundle mainBundle] bundleIdentifier] isEqualToString:@"com.apple.dashboard.client"] &&
100         [[[_pluginPackage.get() bundle] bundleIdentifier] isEqualToString:@"com.apple.QuickTime Plugin.plugin"]) {
101         RetainPtr<NSMutableArray> mutableKeys(AdoptNS, [keys mutableCopy]);
102         RetainPtr<NSMutableArray> mutableValues(AdoptNS, [values mutableCopy]);
103
104         [mutableKeys.get() addObject:@"kioskmode"];
105         [mutableValues.get() addObject:@"true"];
106         [self setAttributeKeys:mutableKeys.get() andValues:mutableValues.get()];
107     } else
108 #endif
109          [self setAttributeKeys:keys andValues:values];
110
111     if (loadManually)
112         _mode = NP_FULL;
113     else
114         _mode = NP_EMBED;
115     
116     _loadManually = loadManually;
117
118     return self;
119 }
120
121 - (void)dealloc
122 {
123     ASSERT(!_isStarted);
124
125     [super dealloc];
126 }
127
128 - (void)finalize
129 {
130     ASSERT_MAIN_THREAD();
131     ASSERT(!_isStarted);
132
133     [super finalize];
134 }
135
136 - (WebNetscapePluginPackage *)pluginPackage
137 {
138     return _pluginPackage.get();
139 }
140     
141 - (BOOL)isFlipped
142 {
143     return YES;
144 }
145
146 - (NSURL *)URLWithCString:(const char *)URLCString
147 {
148     if (!URLCString)
149         return nil;
150     
151     CFStringRef string = CFStringCreateWithCString(kCFAllocatorDefault, URLCString, kCFStringEncodingISOLatin1);
152     ASSERT(string); // All strings should be representable in ISO Latin 1
153     
154     NSString *URLString = [(NSString *)string _web_stringByStrippingReturnCharacters];
155     NSURL *URL = [NSURL _web_URLWithDataAsString:URLString relativeToURL:_baseURL.get()];
156     CFRelease(string);
157     if (!URL)
158         return nil;
159     
160     return URL;
161 }
162
163 - (NSMutableURLRequest *)requestWithURLCString:(const char *)URLCString
164 {
165     NSURL *URL = [self URLWithCString:URLCString];
166     if (!URL)
167         return nil;
168     
169     NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:URL];
170     Frame* frame = core([self webFrame]);
171     if (!frame)
172         return nil;
173     [request _web_setHTTPReferrer:frame->loader()->outgoingReferrer()];
174     return request;
175 }
176
177 // Methods that subclasses must override
178 - (void)setAttributeKeys:(NSArray *)keys andValues:(NSArray *)values
179 {
180     ASSERT_NOT_REACHED();
181 }
182
183 - (void)handleMouseMoved:(NSEvent *)event
184 {
185     ASSERT_NOT_REACHED();
186 }
187
188 - (void)focusChanged
189 {
190     ASSERT_NOT_REACHED();
191 }
192
193 - (void)windowFocusChanged:(BOOL)hasFocus
194 {
195     ASSERT_NOT_REACHED();
196 }
197
198 - (BOOL)createPlugin
199 {
200     ASSERT_NOT_REACHED();
201     return NO;
202 }
203
204 - (void)loadStream
205 {
206     ASSERT_NOT_REACHED();
207 }
208
209 - (BOOL)shouldStop
210 {
211     ASSERT_NOT_REACHED();
212     return YES;
213 }
214
215 - (void)destroyPlugin
216 {
217     ASSERT_NOT_REACHED();
218 }
219
220 - (void)updateAndSetWindow
221 {
222     ASSERT_NOT_REACHED();
223 }
224
225 - (void)sendModifierEventWithKeyCode:(int)keyCode character:(char)character
226 {
227     ASSERT_NOT_REACHED();
228 }
229
230 - (void)removeTrackingRect
231 {
232     if (_trackingTag) {
233         [self removeTrackingRect:_trackingTag];
234         _trackingTag = 0;
235         
236         // Do the following after setting trackingTag to 0 so we don't re-enter.
237         
238         // Balance the retain in resetTrackingRect. Use autorelease in case we hold 
239         // the last reference to the window during tear-down, to avoid crashing AppKit. 
240         [[self window] autorelease];
241     }
242 }
243
244 - (void)resetTrackingRect
245 {
246     [self removeTrackingRect];
247     if (_isStarted) {
248         // Retain the window so that removeTrackingRect can work after the window is closed.
249         [[self window] retain];
250         _trackingTag = [self addTrackingRect:[self bounds] owner:self userData:nil assumeInside:NO];
251     }
252 }
253
254 - (void)stopTimers
255 {
256     _shouldFireTimers = NO;
257 }
258
259 - (void)startTimers
260 {
261     _shouldFireTimers = YES;
262 }
263
264 - (void)restartTimers
265 {
266     ASSERT([self window]);
267     
268     [self stopTimers];
269     
270     if (!_isStarted || [[self window] isMiniaturized])
271         return;
272     
273     [self startTimers];
274 }
275
276 - (NSRect)_windowClipRect
277 {
278     RenderObject* renderer = _element->renderer();
279     
280     if (renderer && renderer->view()) {
281         if (FrameView* frameView = renderer->view()->frameView())
282             return frameView->windowClipRectForLayer(renderer->enclosingLayer(), true);
283     }
284     
285     return NSZeroRect;
286 }
287
288 - (NSRect)visibleRect
289 {
290     // WebCore may impose an additional clip (via CSS overflow or clip properties).  Fetch
291     // that clip now.    
292     return NSIntersectionRect([self convertRect:[self _windowClipRect] fromView:nil], [super visibleRect]);
293 }
294
295 - (BOOL)acceptsFirstResponder
296 {
297     return YES;
298 }
299
300 - (void)sendActivateEvent:(BOOL)activate
301 {
302     if (!_isStarted)
303         return;
304     
305     [self windowFocusChanged:activate];
306 }
307
308 - (void)setHasFocus:(BOOL)flag
309 {
310     if (!_isStarted)
311         return;
312     
313     if (_hasFocus == flag)
314         return;
315     
316     _hasFocus = flag;
317     
318     [self focusChanged];
319 }
320
321 - (void)addWindowObservers
322 {
323     ASSERT([self window]);
324     
325     NSWindow *theWindow = [self window];
326     
327     NSNotificationCenter *notificationCenter = [NSNotificationCenter defaultCenter];
328     [notificationCenter addObserver:self selector:@selector(windowWillClose:) 
329                                name:NSWindowWillCloseNotification object:theWindow]; 
330     [notificationCenter addObserver:self selector:@selector(windowBecameKey:)
331                                name:NSWindowDidBecomeKeyNotification object:theWindow];
332     [notificationCenter addObserver:self selector:@selector(windowResignedKey:)
333                                name:NSWindowDidResignKeyNotification object:theWindow];
334     [notificationCenter addObserver:self selector:@selector(windowDidMiniaturize:)
335                                name:NSWindowDidMiniaturizeNotification object:theWindow];
336     [notificationCenter addObserver:self selector:@selector(windowDidDeminiaturize:)
337                                name:NSWindowDidDeminiaturizeNotification object:theWindow];
338     
339     [notificationCenter addObserver:self selector:@selector(loginWindowDidSwitchFromUser:)
340                                name:LoginWindowDidSwitchFromUserNotification object:nil];
341     [notificationCenter addObserver:self selector:@selector(loginWindowDidSwitchToUser:)
342                                name:LoginWindowDidSwitchToUserNotification object:nil];
343 }
344
345 - (void)removeWindowObservers
346 {
347     NSNotificationCenter *notificationCenter = [NSNotificationCenter defaultCenter];
348     [notificationCenter removeObserver:self name:NSWindowWillCloseNotification        object:nil]; 
349     [notificationCenter removeObserver:self name:NSWindowDidBecomeKeyNotification     object:nil];
350     [notificationCenter removeObserver:self name:NSWindowDidResignKeyNotification     object:nil];
351     [notificationCenter removeObserver:self name:NSWindowDidMiniaturizeNotification   object:nil];
352     [notificationCenter removeObserver:self name:NSWindowDidDeminiaturizeNotification object:nil];
353     [notificationCenter removeObserver:self name:LoginWindowDidSwitchFromUserNotification   object:nil];
354     [notificationCenter removeObserver:self name:LoginWindowDidSwitchToUserNotification     object:nil];
355 }
356
357 - (void)start
358 {
359     ASSERT([self currentWindow]);
360     
361     if (_isStarted)
362         return;
363     
364     if (_triedAndFailedToCreatePlugin)
365         return;
366     
367     ASSERT([self webView]);
368     
369     if (![[[self webView] preferences] arePlugInsEnabled])
370         return;
371    
372     Frame* frame = core([self webFrame]);
373     if (!frame)
374         return;
375     Page* page = frame->page();
376     if (!page)
377         return;
378     
379     bool wasDeferring = page->defersLoading();
380     if (!wasDeferring)
381         page->setDefersLoading(true);
382
383     BOOL result = [self createPlugin];
384     
385     if (!wasDeferring)
386         page->setDefersLoading(false);
387
388     if (!result) {
389         _triedAndFailedToCreatePlugin = YES;
390         return;
391     }
392     
393     _isStarted = YES;
394     [[self webView] addPluginInstanceView:self];
395
396     if ([self currentWindow])
397         [self updateAndSetWindow];
398
399     if ([self window]) {
400         [self addWindowObservers];
401         if ([[self window] isKeyWindow]) {
402             [self sendActivateEvent:YES];
403         }
404         [self restartTimers];
405     }
406     
407     [self resetTrackingRect];
408     
409     [self loadStream];
410 }
411
412 - (void)stop
413 {
414     if (![self shouldStop])
415         return;
416     
417     [self removeTrackingRect];
418     
419     if (!_isStarted)
420         return;
421     
422     _isStarted = NO;
423     
424     [[self webView] removePluginInstanceView:self];
425     
426     // Stop the timers
427     [self stopTimers];
428     
429     // Stop notifications and callbacks.
430     [self removeWindowObservers];
431     
432     [self destroyPlugin];
433 }
434
435 - (void)viewWillMoveToWindow:(NSWindow *)newWindow
436 {
437     // We must remove the tracking rect before we move to the new window.
438     // Once we move to the new window, it will be too late.
439     [self removeTrackingRect];
440     [self removeWindowObservers];
441     
442     // Workaround for: <rdar://problem/3822871> resignFirstResponder is not sent to first responder view when it is removed from the window
443     [self setHasFocus:NO];
444     
445     if (!newWindow) {
446         if ([[self webView] hostWindow]) {
447             // View will be moved out of the actual window but it still has a host window.
448             [self stopTimers];
449         } else {
450             // View will have no associated windows.
451             [self stop];
452             
453             // Stop observing WebPreferencesChangedNotification -- we only need to observe this when installed in the view hierarchy.
454             // When not in the view hierarchy, -viewWillMoveToWindow: and -viewDidMoveToWindow will start/stop the plugin as needed.
455             [[NSNotificationCenter defaultCenter] removeObserver:self name:WebPreferencesChangedNotification object:nil];
456         }
457     }
458 }
459
460 - (void)viewWillMoveToSuperview:(NSView *)newSuperview
461 {
462     if (!newSuperview) {
463         // Stop the plug-in when it is removed from its superview.  It is not sufficient to do this in -viewWillMoveToWindow:nil, because
464         // the WebView might still has a hostWindow at that point, which prevents the plug-in from being destroyed.
465         // There is no need to start the plug-in when moving into a superview.  -viewDidMoveToWindow takes care of that.
466         [self stop];
467         
468         // Stop observing WebPreferencesChangedNotification -- we only need to observe this when installed in the view hierarchy.
469         // When not in the view hierarchy, -viewWillMoveToWindow: and -viewDidMoveToWindow will start/stop the plugin as needed.
470         [[NSNotificationCenter defaultCenter] removeObserver:self name:WebPreferencesChangedNotification object:nil];
471     }
472 }
473
474 - (void)viewDidMoveToWindow
475 {
476     [self resetTrackingRect];
477     
478     if ([self window]) {
479         // While in the view hierarchy, observe WebPreferencesChangedNotification so that we can start/stop depending
480         // on whether plugins are enabled.
481         [[NSNotificationCenter defaultCenter] addObserver:self
482                                                  selector:@selector(preferencesHaveChanged:)
483                                                      name:WebPreferencesChangedNotification
484                                                    object:nil];
485         
486         // View moved to an actual window. Start it if not already started.
487         [self start];
488     } else if ([[self webView] hostWindow]) {
489         // View moved out of an actual window, but still has a host window.
490         // Call setWindow to explicitly "clip out" the plug-in from sight.
491         // FIXME: It would be nice to do this where we call stopNullEvents in viewWillMoveToWindow.
492         [self updateAndSetWindow];
493     }
494 }
495
496 - (void)viewWillMoveToHostWindow:(NSWindow *)hostWindow
497 {
498     if (!hostWindow && ![self window]) {
499         // View will have no associated windows.
500         [self stop];
501         
502         // Remove WebPreferencesChangedNotification observer -- we will observe once again when we move back into the window
503         [[NSNotificationCenter defaultCenter] removeObserver:self name:WebPreferencesChangedNotification object:nil];
504     }
505 }
506
507 - (void)viewDidMoveToHostWindow
508 {
509     if ([[self webView] hostWindow]) {
510         // View now has an associated window. Start it if not already started.
511         [self start];
512     }
513 }
514
515 #pragma mark NOTIFICATIONS
516
517 - (void)windowWillClose:(NSNotification *)notification 
518 {
519     [self stop]; 
520
521
522 - (void)windowBecameKey:(NSNotification *)notification
523 {
524     [self sendActivateEvent:YES];
525     [self invalidatePluginContentRect:[self bounds]];
526     [self restartTimers];
527 }
528
529 - (void)windowResignedKey:(NSNotification *)notification
530 {
531     [self sendActivateEvent:NO];
532     [self invalidatePluginContentRect:[self bounds]];
533     [self restartTimers];
534 }
535
536 - (void)windowDidMiniaturize:(NSNotification *)notification
537 {
538     [self stopTimers];
539 }
540
541 - (void)windowDidDeminiaturize:(NSNotification *)notification
542 {
543     [self restartTimers];
544 }
545
546 - (void)loginWindowDidSwitchFromUser:(NSNotification *)notification
547 {
548     [self stopTimers];
549 }
550
551 -(void)loginWindowDidSwitchToUser:(NSNotification *)notification
552 {
553     [self restartTimers];
554 }
555
556 - (void)preferencesHaveChanged:(NSNotification *)notification
557 {
558     WebPreferences *preferences = [[self webView] preferences];
559     BOOL arePlugInsEnabled = [preferences arePlugInsEnabled];
560     
561     if ([notification object] == preferences && _isStarted != arePlugInsEnabled) {
562         if (arePlugInsEnabled) {
563             if ([self currentWindow]) {
564                 [self start];
565             }
566         } else {
567             [self stop];
568             [self invalidatePluginContentRect:[self bounds]];
569         }
570     }
571 }
572
573 - (void)renewGState
574 {
575     [super renewGState];
576     
577     // -renewGState is called whenever the view's geometry changes.  It's a little hacky to override this method, but
578     // much safer than walking up the view hierarchy and observing frame/bounds changed notifications, since you don't
579     // have to track subsequent changes to the view hierarchy and add/remove notification observers.
580     // NSOpenGLView uses the exact same technique to reshape its OpenGL surface.
581     
582     // All of the work this method does may safely be skipped if the view is not in a window.  When the view
583     // is moved back into a window, everything should be set up correctly.
584     if (![self window])
585         return;
586     
587     [self updateAndSetWindow];
588     
589     [self resetTrackingRect];
590     
591     // Check to see if the plugin view is completely obscured (scrolled out of view, for example).
592     // For performance reasons, we send null events at a lower rate to plugins which are obscured.
593     BOOL oldIsObscured = _isCompletelyObscured;
594     _isCompletelyObscured = NSIsEmptyRect([self visibleRect]);
595     if (_isCompletelyObscured != oldIsObscured)
596         [self restartTimers];
597 }
598
599 - (BOOL)becomeFirstResponder
600 {
601     [self setHasFocus:YES];
602     return YES;
603 }
604
605 - (BOOL)resignFirstResponder
606 {
607     [self setHasFocus:NO];    
608     return YES;
609 }
610
611 - (WebDataSource *)dataSource
612 {
613     WebFrame *webFrame = kit(_element->document()->frame());
614     return [webFrame _dataSource];
615 }
616
617 - (WebFrame *)webFrame
618 {
619     return [[self dataSource] webFrame];
620 }
621
622 - (WebView *)webView
623 {
624     return [[self webFrame] webView];
625 }
626
627 - (NSWindow *)currentWindow
628 {
629     return [self window] ? [self window] : [[self webView] hostWindow];
630 }
631
632 - (WebCore::HTMLPlugInElement*)element
633 {
634     return _element.get();
635 }
636
637 - (void)cut:(id)sender
638 {
639     [self sendModifierEventWithKeyCode:7 character:'x'];
640 }
641
642 - (void)copy:(id)sender
643 {
644     [self sendModifierEventWithKeyCode:8 character:'c'];
645 }
646
647 - (void)paste:(id)sender
648 {
649     [self sendModifierEventWithKeyCode:9 character:'v'];
650 }
651
652 - (void)selectAll:(id)sender
653 {
654     [self sendModifierEventWithKeyCode:0 character:'a'];
655 }
656
657 // AppKit doesn't call mouseDown or mouseUp on right-click. Simulate control-click
658 // mouseDown and mouseUp so plug-ins get the right-click event as they do in Carbon (3125743).
659 - (void)rightMouseDown:(NSEvent *)theEvent
660 {
661     [self mouseDown:theEvent];
662 }
663
664 - (void)rightMouseUp:(NSEvent *)theEvent
665 {
666     [self mouseUp:theEvent];
667 }
668
669
670 - (BOOL)convertFromX:(double)sourceX andY:(double)sourceY space:(NPCoordinateSpace)sourceSpace
671                  toX:(double *)destX andY:(double *)destY space:(NPCoordinateSpace)destSpace
672 {
673     // Nothing to do
674     if (sourceSpace == destSpace)
675         return TRUE;
676     
677     NSPoint sourcePoint = NSMakePoint(sourceX, sourceY);
678     
679     NSPoint sourcePointInScreenSpace;
680     
681     // First convert to screen space
682     switch (sourceSpace) {
683         case NPCoordinateSpacePlugin:
684             sourcePointInScreenSpace = [self convertPoint:sourcePoint toView:nil];
685             sourcePointInScreenSpace = [[self currentWindow] convertBaseToScreen:sourcePointInScreenSpace];
686             break;
687             
688         case NPCoordinateSpaceWindow:
689             sourcePointInScreenSpace = [[self currentWindow] convertBaseToScreen:sourcePoint];
690             break;
691             
692         case NPCoordinateSpaceFlippedWindow:
693             sourcePoint.y = [[self currentWindow] frame].size.height - sourcePoint.y;
694             sourcePointInScreenSpace = [[self currentWindow] convertBaseToScreen:sourcePoint];
695             break;
696             
697         case NPCoordinateSpaceScreen:
698             sourcePointInScreenSpace = sourcePoint;
699             break;
700             
701         case NPCoordinateSpaceFlippedScreen:
702             sourcePoint.y = [[[NSScreen screens] objectAtIndex:0] frame].size.height - sourcePoint.y;
703             sourcePointInScreenSpace = sourcePoint;
704             break;
705         default:
706             return FALSE;
707     }
708     
709     NSPoint destPoint;
710     
711     // Then convert back to the destination space
712     switch (destSpace) {
713         case NPCoordinateSpacePlugin:
714             destPoint = [[self currentWindow] convertScreenToBase:sourcePointInScreenSpace];
715             destPoint = [self convertPoint:destPoint fromView:nil];
716             break;
717             
718         case NPCoordinateSpaceWindow:
719             destPoint = [[self currentWindow] convertScreenToBase:sourcePointInScreenSpace];
720             break;
721             
722         case NPCoordinateSpaceFlippedWindow:
723             destPoint = [[self currentWindow] convertScreenToBase:sourcePointInScreenSpace];
724             destPoint.y = [[self currentWindow] frame].size.height - destPoint.y;
725             break;
726             
727         case NPCoordinateSpaceScreen:
728             destPoint = sourcePointInScreenSpace;
729             break;
730             
731         case NPCoordinateSpaceFlippedScreen:
732             destPoint = sourcePointInScreenSpace;
733             destPoint.y = [[[NSScreen screens] objectAtIndex:0] frame].size.height - destPoint.y;
734             break;
735             
736         default:
737             return FALSE;
738     }
739     
740     if (destX)
741         *destX = destPoint.x;
742     if (destY)
743         *destY = destPoint.y;
744     
745     return TRUE;
746 }
747
748
749 - (CString)resolvedURLStringForURL:(const char*)url target:(const char*)target;
750 {
751     String relativeURLString = String::fromUTF8(url);
752     if (relativeURLString.isNull())
753         return CString();
754     
755     Frame* frame = core([self webFrame]);
756     if (!frame)
757         return CString();
758
759     Frame* targetFrame = frame->tree()->find(String::fromUTF8(target));
760     if (!targetFrame)
761         return CString();
762     
763     if (!frame->document()->securityOrigin()->canAccess(targetFrame->document()->securityOrigin()))
764         return CString();
765   
766     KURL absoluteURL = targetFrame->loader()->completeURL(relativeURLString);
767     return absoluteURL.string().utf8();
768 }
769
770 - (void)invalidatePluginContentRect:(NSRect)rect
771 {
772     if (RenderBoxModelObject *renderer = toRenderBoxModelObject(_element->renderer())) {
773         IntRect contentRect(rect);
774         contentRect.move(renderer->borderLeft() + renderer->paddingLeft(), renderer->borderTop() + renderer->paddingTop());
775         
776         renderer->repaintRectangle(contentRect);
777     }
778 }
779
780 @end
781
782 namespace WebKit {
783
784 #if !defined(BUILDING_ON_TIGER) && !defined(BUILDING_ON_LEOPARD)
785 CString proxiesForURL(NSURL *url)
786 {
787     RetainPtr<CFDictionaryRef> systemProxies(AdoptCF, CFNetworkCopySystemProxySettings());
788     if (!systemProxies)
789         return "DIRECT";
790     
791     RetainPtr<CFArrayRef> proxiesForURL(AdoptCF, CFNetworkCopyProxiesForURL((CFURLRef)url, systemProxies.get()));
792     CFIndex proxyCount = proxiesForURL ? CFArrayGetCount(proxiesForURL.get()) : 0;
793     if (!proxyCount)
794         return "DIRECT";
795  
796     // proxiesForURL is a CFArray of CFDictionaries. Each dictionary represents a proxy.
797     // The format of the result should be:
798     // "PROXY host[:port]" (for HTTP proxy) or
799     // "SOCKS host[:port]" (for SOCKS proxy) or
800     // A combination of the above, separated by semicolon, in the order that they should be tried.
801     String proxies;
802     for (CFIndex i = 0; i < proxyCount; ++i) {
803         CFDictionaryRef proxy = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(proxiesForURL.get(), i));
804         if (!proxy)
805             continue;
806
807         CFStringRef type = static_cast<CFStringRef>(CFDictionaryGetValue(proxy, kCFProxyTypeKey));
808         bool isHTTP = type == kCFProxyTypeHTTP || type == kCFProxyTypeHTTPS;
809         bool isSOCKS = type == kCFProxyTypeSOCKS;
810         
811         // We can only report HTTP and SOCKS proxies.
812         if (!isHTTP && !isSOCKS)
813             continue;
814         
815         CFStringRef host = static_cast<CFStringRef>(CFDictionaryGetValue(proxy, kCFProxyHostNameKey));
816         CFNumberRef port = static_cast<CFNumberRef>(CFDictionaryGetValue(proxy, kCFProxyPortNumberKey));
817         
818         // If we are inserting multiple entries, add a separator
819         if (!proxies.isEmpty())
820             proxies += ";";
821         
822         if (isHTTP)
823             proxies += "PROXY ";
824         else if (isSOCKS)
825             proxies += "SOCKS ";
826         
827         proxies += host;
828
829         if (port) {
830             SInt32 intPort;
831             CFNumberGetValue(port, kCFNumberSInt32Type, &intPort);
832             
833             proxies += ":" + String::number(intPort);
834         }
835     }
836     
837     if (proxies.isEmpty())
838         return "DIRECT";
839     
840     return proxies.utf8();
841 }
842 #endif
843
844 bool getAuthenticationInfo(const char* protocolStr, const char* hostStr, int32_t port, const char* schemeStr, const char* realmStr,
845                            CString& username, CString& password)
846 {
847     if (strcasecmp(protocolStr, "http") != 0 && 
848         strcasecmp(protocolStr, "https") != 0)
849         return false;
850
851     NSString *host = [NSString stringWithUTF8String:hostStr];
852     if (!hostStr)
853         return false;
854     
855     NSString *protocol = [NSString stringWithUTF8String:protocolStr];
856     if (!protocol)
857         return false;
858     
859     NSString *realm = [NSString stringWithUTF8String:realmStr];
860     if (!realm)
861         return NPERR_GENERIC_ERROR;
862     
863     NSString *authenticationMethod = NSURLAuthenticationMethodDefault;
864     if (!strcasecmp(protocolStr, "http")) {
865         if (!strcasecmp(schemeStr, "basic"))
866             authenticationMethod = NSURLAuthenticationMethodHTTPBasic;
867         else if (!strcasecmp(schemeStr, "digest"))
868             authenticationMethod = NSURLAuthenticationMethodHTTPDigest;
869     }
870     
871     RetainPtr<NSURLProtectionSpace> protectionSpace(AdoptNS, [[NSURLProtectionSpace alloc] initWithHost:host port:port protocol:protocol realm:realm authenticationMethod:authenticationMethod]);
872     
873     NSURLCredential *credential = mac(CredentialStorage::get(core(protectionSpace.get())));
874     if (!credential)
875         credential = [[NSURLCredentialStorage sharedCredentialStorage] defaultCredentialForProtectionSpace:protectionSpace.get()];
876     if (!credential)
877         return false;
878   
879     if (![credential hasPassword])
880         return false;
881     
882     username = [[credential user] UTF8String];
883     password = [[credential password] UTF8String];
884     
885     return true;
886 }
887     
888 } // namespace WebKit
889
890 #endif //  ENABLE(NETSCAPE_PLUGIN_API)
891