WebKit/mac/WebCoreSupport/WebChromeClient.mm

   1 /*
   2  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
   3  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
   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  *
   9  * 1.  Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  * 2.  Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  15  *     its contributors may be used to endorse or promote products derived
  16  *     from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #import "WebChromeClient.h"
  31
  32 #import <Foundation/Foundation.h>
  33 #import "WebDefaultUIDelegate.h"
  34 #import "WebElementDictionary.h"
  35 #import "WebFrameInternal.h"
  36 #import "WebFrameView.h"
  37 #import "WebHTMLViewInternal.h"
  38 #import "WebHistoryInternal.h"
  39 #import "WebKitSystemInterface.h"
  40 #import "WebKitPrefix.h"
  41 #import "WebNSURLRequestExtras.h"
  42 #import "WebPlugin.h"
  43 #import "WebSecurityOriginInternal.h"
  44 #import "WebUIDelegatePrivate.h"
  45 #import "WebView.h"
  46 #import "WebViewInternal.h"
  47 #import <WebCore/BlockExceptions.h>
  48 #import <WebCore/FileChooser.h>
  49 #import <WebCore/FloatRect.h>
  50 #import <WebCore/Frame.h>
  51 #import <WebCore/FrameLoadRequest.h>
  52 #import <WebCore/HitTestResult.h>
  53 #import <WebCore/IntRect.h>
  54 #import <WebCore/Page.h>
  55 #import <WebCore/PlatformScreen.h>
  56 #import <WebCore/PlatformString.h>
  57 #import <WebCore/ResourceRequest.h>
  58 #import <WebCore/Widget.h>
  59 #import <WebCore/WindowFeatures.h>
  60 #import <wtf/PassRefPtr.h>
  61 #import <wtf/Vector.h>
  62
  63 @interface NSView (WebNSViewDetails)
  64 - (NSView *)_findLastViewInKeyViewLoop;
  65 @end
  66
  67 // For compatibility with old SPI.
  68 @interface NSView (WebOldWebKitPlugInDetails)
  69 - (void)setIsSelected:(BOOL)isSelected;
  70 @end
  71
  72 @interface NSWindow (AppKitSecretsIKnowAbout)
  73 - (NSRect)_growBoxRect;
  74 @end
  75
  76 using namespace WebCore;
  77
  78 @interface WebOpenPanelResultListener : NSObject <WebOpenPanelResultListener> {
  79     FileChooser* _chooser;
  80 }
  81 - (id)initWithChooser:(PassRefPtr<FileChooser>)chooser;
  82 @end
  83
  84 WebChromeClient::WebChromeClient(WebView *webView)
  85     : m_webView(webView)
  86 {
  87 }
  88
  89 void WebChromeClient::chromeDestroyed()
  90 {
  91     delete this;
  92 }
  93
  94 // These functions scale between window and WebView coordinates because JavaScript/DOM operations
  95 // assume that the WebView and the window share the same coordinate system.
  96
  97 void WebChromeClient::setWindowRect(const FloatRect& rect)
  98 {
  99     NSRect windowRect = toDeviceSpace(rect, [m_webView window]);
 100     [[m_webView _UIDelegateForwarder] webView:m_webView setFrame:windowRect];
 101 }
 102
 103 FloatRect WebChromeClient::windowRect()
 104 {
 105     NSRect windowRect = [[m_webView _UIDelegateForwarder] webViewFrame:m_webView];
 106     return toUserSpace(windowRect, [m_webView window]);
 107 }
 108
 109 // FIXME: We need to add API for setting and getting this.
 110 FloatRect WebChromeClient::pageRect()
 111 {
 112     return [m_webView frame];
 113 }
 114
 115 float WebChromeClient::scaleFactor()
 116 {
 117     if (NSWindow *window = [m_webView window])
 118         return [window  userSpaceScaleFactor];
 119     return [[NSScreen mainScreen] userSpaceScaleFactor];
 120 }
 121
 122 void WebChromeClient::focus()
 123 {
 124     [[m_webView _UIDelegateForwarder] webViewFocus:m_webView];
 125 }
 126
 127 void WebChromeClient::unfocus()
 128 {
 129     [[m_webView _UIDelegateForwarder] webViewUnfocus:m_webView];
 130 }
 131
 132 bool WebChromeClient::canTakeFocus(FocusDirection)
 133 {
 134     // There's unfortunately no way to determine if we will become first responder again
 135     // once we give it up, so we just have to guess that we won't.
 136     return true;
 137 }
 138
 139 void WebChromeClient::takeFocus(FocusDirection direction)
 140 {
 141     if (direction == FocusDirectionForward) {
 142         // Since we're trying to move focus out of m_webView, and because
 143         // m_webView may contain subviews within it, we ask it for the next key
 144         // view of the last view in its key view loop. This makes m_webView
 145         // behave as if it had no subviews, which is the behavior we want.
 146         NSView *lastView = [m_webView _findLastViewInKeyViewLoop];
 147         // avoid triggering assertions if the WebView is the only thing in the key loop
 148         if ([m_webView _becomingFirstResponderFromOutside] && m_webView == [lastView nextValidKeyView])
 149             return;
 150         [[m_webView window] selectKeyViewFollowingView:lastView];
 151     } else {
 152         // avoid triggering assertions if the WebView is the only thing in the key loop
 153         if ([m_webView _becomingFirstResponderFromOutside] && m_webView == [m_webView previousValidKeyView])
 154             return;
 155         [[m_webView window] selectKeyViewPrecedingView:m_webView];
 156     }
 157 }
 158
 159 Page* WebChromeClient::createWindow(Frame* frame, const FrameLoadRequest& request, const WindowFeatures& features)
 160 {
 161     NSURLRequest *URLRequest = nil;
 162     if (!request.isEmpty())
 163         URLRequest = request.resourceRequest().nsURLRequest();
 164
 165     id delegate = [m_webView UIDelegate];
 166     WebView *newWebView;
 167
 168     if ([delegate respondsToSelector:@selector(webView:createWebViewWithRequest:windowFeatures:)]) {
 169         NSNumber *x = features.xSet ? [[NSNumber alloc] initWithFloat:features.x] : nil;
 170         NSNumber *y = features.ySet ? [[NSNumber alloc] initWithFloat:features.y] : nil;
 171         NSNumber *width = features.widthSet ? [[NSNumber alloc] initWithFloat:features.width] : nil;
 172         NSNumber *height = features.heightSet ? [[NSNumber alloc] initWithFloat:features.height] : nil;
 173         NSNumber *menuBarVisible = [[NSNumber alloc] initWithBool:features.menuBarVisible];
 174         NSNumber *statusBarVisible = [[NSNumber alloc] initWithBool:features.statusBarVisible];
 175         NSNumber *toolBarVisible = [[NSNumber alloc] initWithBool:features.toolBarVisible];
 176         NSNumber *scrollbarsVisible = [[NSNumber alloc] initWithBool:features.scrollbarsVisible];
 177         NSNumber *resizable = [[NSNumber alloc] initWithBool:features.resizable];
 178         NSNumber *fullscreen = [[NSNumber alloc] initWithBool:features.fullscreen];
 179         NSNumber *dialog = [[NSNumber alloc] initWithBool:features.dialog];
 180
 181         NSMutableDictionary *dictFeatures = [[NSMutableDictionary alloc] initWithObjectsAndKeys:
 182                                              menuBarVisible, @"menuBarVisible",
 183                                              statusBarVisible, @"statusBarVisible",
 184                                              toolBarVisible, @"toolBarVisible",
 185                                              scrollbarsVisible, @"scrollbarsVisible",
 186                                              resizable, @"resizable",
 187                                              fullscreen, @"fullscreen",
 188                                              dialog, @"dialog",
 189                                              nil];
 190
 191         if (x)
 192             [dictFeatures setObject:x forKey:@"x"];
 193         if (y)
 194             [dictFeatures setObject:y forKey:@"y"];
 195         if (width)
 196             [dictFeatures setObject:width forKey:@"width"];
 197         if (height)
 198             [dictFeatures setObject:height forKey:@"height"];
 199
 200         newWebView = CallUIDelegate(m_webView, @selector(webView:createWebViewWithRequest:windowFeatures:), URLRequest, dictFeatures);
 201
 202         [dictFeatures release];
 203         [x release];
 204         [y release];
 205         [width release];
 206         [height release];
 207         [menuBarVisible release];
 208         [statusBarVisible release];
 209         [toolBarVisible release];
 210         [scrollbarsVisible release];
 211         [resizable release];
 212         [fullscreen release];
 213         [dialog release];
 214     } else if (features.dialog && [delegate respondsToSelector:@selector(webView:createWebViewModalDialogWithRequest:)]) {
 215         newWebView = CallUIDelegate(m_webView, @selector(webView:createWebViewModalDialogWithRequest:), URLRequest);
 216     } else {
 217         newWebView = CallUIDelegate(m_webView, @selector(webView:createWebViewWithRequest:), URLRequest);
 218     }
 219
 220     return core(newWebView);
 221 }
 222
 223 void WebChromeClient::show()
 224 {
 225     [[m_webView _UIDelegateForwarder] webViewShow:m_webView];
 226 }
 227
 228 bool WebChromeClient::canRunModal()
 229 {
 230     return [[m_webView UIDelegate] respondsToSelector:@selector(webViewRunModal:)];
 231 }
 232
 233 void WebChromeClient::runModal()
 234 {
 235     CallUIDelegate(m_webView, @selector(webViewRunModal:));
 236 }
 237
 238 void WebChromeClient::setToolbarsVisible(bool b)
 239 {
 240     [[m_webView _UIDelegateForwarder] webView:m_webView setToolbarsVisible:b];
 241 }
 242
 243 bool WebChromeClient::toolbarsVisible()
 244 {
 245     return CallUIDelegateReturningBoolean(NO, m_webView, @selector(webViewAreToolbarsVisible:));
 246 }
 247
 248 void WebChromeClient::setStatusbarVisible(bool b)
 249 {
 250     [[m_webView _UIDelegateForwarder] webView:m_webView setStatusBarVisible:b];
 251 }
 252
 253 bool WebChromeClient::statusbarVisible()
 254 {
 255     return CallUIDelegateReturningBoolean(NO, m_webView, @selector(webViewIsStatusBarVisible:));
 256 }
 257
 258 void WebChromeClient::setScrollbarsVisible(bool b)
 259 {
 260     [[[m_webView mainFrame] frameView] setAllowsScrolling:b];
 261 }
 262
 263 bool WebChromeClient::scrollbarsVisible()
 264 {
 265     return [[[m_webView mainFrame] frameView] allowsScrolling];
 266 }
 267
 268 void WebChromeClient::setMenubarVisible(bool)
 269 {
 270     // The menubar is always visible in Mac OS X.
 271     return;
 272 }
 273
 274 bool WebChromeClient::menubarVisible()
 275 {
 276     // The menubar is always visible in Mac OS X.
 277     return true;
 278 }
 279
 280 void WebChromeClient::setResizable(bool b)
 281 {
 282     [[m_webView _UIDelegateForwarder] webView:m_webView setResizable:b];
 283 }
 284
 285 void WebChromeClient::addMessageToConsole(const String& message, unsigned int lineNumber, const String& sourceURL)
 286 {
 287     id delegate = [m_webView UIDelegate];
 288     SEL selector = @selector(webView:addMessageToConsole:);
 289     if (![delegate respondsToSelector:selector])
 290         return;
 291
 292     NSDictionary *dictionary = [[NSDictionary alloc] initWithObjectsAndKeys:
 293         (NSString *)message, @"message", [NSNumber numberWithUnsignedInt:lineNumber], @"lineNumber",
 294         (NSString *)sourceURL, @"sourceURL", NULL];
 295
 296     CallUIDelegate(m_webView, selector, dictionary);
 297
 298     [dictionary release];
 299 }
 300
 301 bool WebChromeClient::canRunBeforeUnloadConfirmPanel()
 302 {
 303     return [[m_webView UIDelegate] respondsToSelector:@selector(webView:runBeforeUnloadConfirmPanelWithMessage:initiatedByFrame:)];
 304 }
 305
 306 bool WebChromeClient::runBeforeUnloadConfirmPanel(const String& message, Frame* frame)
 307 {
 308     return CallUIDelegateReturningBoolean(true, m_webView, @selector(webView:runBeforeUnloadConfirmPanelWithMessage:initiatedByFrame:), message, kit(frame));
 309 }
 310
 311 void WebChromeClient::closeWindowSoon()
 312 {
 313     // We need to remove the parent WebView from WebViewSets here, before it actually
 314     // closes, to make sure that JavaScript code that executes before it closes
 315     // can't find it. Otherwise, window.open will select a closed WebView instead of
 316     // opening a new one <rdar://problem/3572585>.
 317
 318     // We also need to stop the load to prevent further parsing or JavaScript execution
 319     // after the window has torn down <rdar://problem/4161660>.
 320
 321     // FIXME: This code assumes that the UI delegate will respond to a webViewClose
 322     // message by actually closing the WebView. Safari guarantees this behavior, but other apps might not.
 323     // This approach is an inherent limitation of not making a close execute immediately
 324     // after a call to window.close.
 325
 326     [m_webView setGroupName:nil];
 327     [m_webView stopLoading:nil];
 328     [m_webView performSelector:@selector(_closeWindow) withObject:nil afterDelay:0.0];
 329 }
 330
 331 void WebChromeClient::runJavaScriptAlert(Frame* frame, const String& message)
 332 {
 333     id delegate = [m_webView UIDelegate];
 334     SEL selector = @selector(webView:runJavaScriptAlertPanelWithMessage:initiatedByFrame:);
 335     if ([delegate respondsToSelector:selector]) {
 336         CallUIDelegate(m_webView, selector, message, kit(frame));
 337         return;
 338     }
 339
 340     // Call the old version of the delegate method if it is implemented.
 341     selector = @selector(webView:runJavaScriptAlertPanelWithMessage:);
 342     if ([delegate respondsToSelector:selector]) {
 343         CallUIDelegate(m_webView, selector, message);
 344         return;
 345     }
 346 }
 347
 348 bool WebChromeClient::runJavaScriptConfirm(Frame* frame, const String& message)
 349 {
 350     id delegate = [m_webView UIDelegate];
 351     SEL selector = @selector(webView:runJavaScriptConfirmPanelWithMessage:initiatedByFrame:);
 352     if ([delegate respondsToSelector:selector])
 353         return CallUIDelegateReturningBoolean(NO, m_webView, selector, message, kit(frame));
 354
 355     // Call the old version of the delegate method if it is implemented.
 356     selector = @selector(webView:runJavaScriptConfirmPanelWithMessage:);
 357     if ([delegate respondsToSelector:selector])
 358         return CallUIDelegateReturningBoolean(NO, m_webView, selector, message);
 359
 360     return NO;
 361 }
 362
 363 bool WebChromeClient::runJavaScriptPrompt(Frame* frame, const String& prompt, const String& defaultText, String& result)
 364 {
 365     id delegate = [m_webView UIDelegate];
 366     SEL selector = @selector(webView:runJavaScriptTextInputPanelWithPrompt:defaultText:initiatedByFrame:);
 367     if ([delegate respondsToSelector:selector]) {
 368         result = (NSString *)CallUIDelegate(m_webView, selector, prompt, defaultText, kit(frame));
 369         return !result.isNull();
 370     }
 371
 372     // Call the old version of the delegate method if it is implemented.
 373     selector = @selector(webView:runJavaScriptTextInputPanelWithPrompt:defaultText:);
 374     if ([delegate respondsToSelector:selector]) {
 375         result = (NSString *)CallUIDelegate(m_webView, selector, prompt, defaultText);
 376         return !result.isNull();
 377     }
 378
 379     result = [[WebDefaultUIDelegate sharedUIDelegate] webView:m_webView runJavaScriptTextInputPanelWithPrompt:prompt defaultText:defaultText initiatedByFrame:kit(frame)];
 380     return !result.isNull();
 381 }
 382
 383 bool WebChromeClient::shouldInterruptJavaScript()
 384 {
 385     return CallUIDelegate(m_webView, @selector(webViewShouldInterruptJavaScript:));
 386 }
 387
 388 void WebChromeClient::setStatusbarText(const String& status)
 389 {
 390     // We want the temporaries allocated here to be released even before returning to the
 391     // event loop; see <http://bugs.webkit.org/show_bug.cgi?id=9880>.
 392     NSAutoreleasePool* localPool = [[NSAutoreleasePool alloc] init];
 393     CallUIDelegate(m_webView, @selector(webView:setStatusText:), (NSString *)status);
 394     [localPool drain];
 395 }
 396
 397 bool WebChromeClient::tabsToLinks() const
 398 {
 399     return [[m_webView preferences] tabsToLinks];
 400 }
 401
 402 IntRect WebChromeClient::windowResizerRect() const
 403 {
 404     NSRect rect = [[m_webView window] _growBoxRect];
 405     if ([m_webView _usesDocumentViews])
 406         return enclosingIntRect(rect);
 407     return enclosingIntRect([m_webView convertRect:rect fromView:nil]);
 408 }
 409
 410 void WebChromeClient::repaint(const IntRect& rect, bool contentChanged, bool immediate, bool repaintContentOnly)
 411 {
 412     if ([m_webView _usesDocumentViews])
 413         return;
 414
 415     if (contentChanged)
 416         [m_webView setNeedsDisplayInRect:rect];
 417
 418     if (immediate) {
 419         [[m_webView window] displayIfNeeded];
 420         [[m_webView window] flushWindowIfNeeded];
 421     }
 422 }
 423
 424 void WebChromeClient::scroll(const IntSize&, const IntRect&, const IntRect&)
 425 {
 426 }
 427
 428 IntPoint WebChromeClient::screenToWindow(const IntPoint& p) const
 429 {
 430     if ([m_webView _usesDocumentViews])
 431         return p;
 432     NSPoint windowCoord = [[m_webView window] convertScreenToBase:p];
 433     return IntPoint([m_webView convertPoint:windowCoord fromView:nil]);
 434 }
 435
 436 IntRect WebChromeClient::windowToScreen(const IntRect& r) const
 437 {
 438     if ([m_webView _usesDocumentViews])
 439         return r;
 440     NSRect tempRect = r;
 441     tempRect = [m_webView convertRect:tempRect toView:nil];
 442     tempRect.origin = [[m_webView window] convertBaseToScreen:tempRect.origin];
 443     return enclosingIntRect(tempRect);
 444 }
 445
 446 PlatformWidget WebChromeClient::platformWindow() const
 447 {
 448     if ([m_webView _usesDocumentViews])
 449         return 0;
 450     return m_webView;
 451 }
 452 // End host window methods.
 453
 454 void WebChromeClient::mouseDidMoveOverElement(const HitTestResult& result, unsigned modifierFlags)
 455 {
 456     WebElementDictionary *element = [[WebElementDictionary alloc] initWithHitTestResult:result];
 457     [m_webView _mouseDidMoveOverElement:element modifierFlags:modifierFlags];
 458     [element release];
 459 }
 460
 461 void WebChromeClient::setToolTip(const String& toolTip)
 462 {
 463     [(WebHTMLView *)[[[m_webView mainFrame] frameView] documentView] _setToolTip:toolTip];
 464 }
 465
 466 void WebChromeClient::print(Frame* frame)
 467 {
 468     WebFrameView* frameView = [kit(frame) frameView];
 469     CallUIDelegate(m_webView, @selector(webView:printFrameView:), frameView);
 470 }
 471
 472 void WebChromeClient::exceededDatabaseQuota(Frame* frame, const String& databaseName)
 473 {
 474     BEGIN_BLOCK_OBJC_EXCEPTIONS;
 475
 476     WebSecurityOrigin *webOrigin = [[WebSecurityOrigin alloc] _initWithWebCoreSecurityOrigin:frame->document()->securityOrigin()];
 477     // FIXME: remove this workaround once shipping Safari has the necessary delegate implemented.
 478     if (WKAppVersionCheckLessThan(@"com.apple.Safari", -1, 3.1)) {
 479         const unsigned long long defaultQuota = 5 * 1024 * 1024; // 5 megabytes should hopefully be enough to test storage support.
 480         [webOrigin setQuota:defaultQuota];
 481     } else
 482         CallUIDelegate(m_webView, @selector(webView:frame:exceededDatabaseQuotaForSecurityOrigin:database:), kit(frame), webOrigin, (NSString *)databaseName);
 483     [webOrigin release];
 484
 485     END_BLOCK_OBJC_EXCEPTIONS;
 486 }
 487
 488 void WebChromeClient::populateVisitedLinks()
 489 {
 490     BEGIN_BLOCK_OBJC_EXCEPTIONS;
 491     [[WebHistory optionalSharedHistory] _addVisitedLinksToPageGroup:[m_webView page]->group()];
 492     END_BLOCK_OBJC_EXCEPTIONS;
 493 }
 494
 495 #if ENABLE(DASHBOARD_SUPPORT)
 496 void WebChromeClient::dashboardRegionsChanged()
 497 {
 498     BEGIN_BLOCK_OBJC_EXCEPTIONS;
 499
 500     NSMutableDictionary *regions = core([m_webView mainFrame])->dashboardRegionsDictionary();
 501     [m_webView _addScrollerDashboardRegions:regions];
 502
 503     CallUIDelegate(m_webView, @selector(webView:dashboardRegionsChanged:), regions);
 504
 505     END_BLOCK_OBJC_EXCEPTIONS;
 506 }
 507 #endif
 508
 509 FloatRect WebChromeClient::customHighlightRect(Node* node, const AtomicString& type, const FloatRect& lineRect)
 510 {
 511     BEGIN_BLOCK_OBJC_EXCEPTIONS;
 512
 513     NSView *documentView = [[kit(node->document()->frame()) frameView] documentView];
 514     if (![documentView isKindOfClass:[WebHTMLView class]])
 515         return NSZeroRect;
 516
 517     WebHTMLView *webHTMLView = (WebHTMLView *)documentView;
 518     id<WebHTMLHighlighter> highlighter = [webHTMLView _highlighterForType:type];
 519     if ([(NSObject *)highlighter respondsToSelector:@selector(highlightRectForLine:representedNode:)])
 520         return [highlighter highlightRectForLine:lineRect representedNode:kit(node)];
 521     return [highlighter highlightRectForLine:lineRect];
 522
 523     END_BLOCK_OBJC_EXCEPTIONS;
 524
 525     return NSZeroRect;
 526 }
 527
 528 void WebChromeClient::paintCustomHighlight(Node* node, const AtomicString& type, const FloatRect& boxRect, const FloatRect& lineRect,
 529     bool behindText, bool entireLine)
 530 {
 531     BEGIN_BLOCK_OBJC_EXCEPTIONS;
 532
 533     NSView *documentView = [[kit(node->document()->frame()) frameView] documentView];
 534     if (![documentView isKindOfClass:[WebHTMLView class]])
 535         return;
 536
 537     WebHTMLView *webHTMLView = (WebHTMLView *)documentView;
 538     id<WebHTMLHighlighter> highlighter = [webHTMLView _highlighterForType:type];
 539     if ([(NSObject *)highlighter respondsToSelector:@selector(paintHighlightForBox:onLine:behindText:entireLine:representedNode:)])
 540         [highlighter paintHighlightForBox:boxRect onLine:lineRect behindText:behindText entireLine:entireLine representedNode:kit(node)];
 541     else
 542         [highlighter paintHighlightForBox:boxRect onLine:lineRect behindText:behindText entireLine:entireLine];
 543
 544     END_BLOCK_OBJC_EXCEPTIONS;
 545 }
 546
 547 void WebChromeClient::runOpenPanel(Frame*, PassRefPtr<FileChooser> chooser)
 548 {
 549     BEGIN_BLOCK_OBJC_EXCEPTIONS;
 550     BOOL allowMultipleFiles = chooser->allowsMultipleFiles();
 551     WebOpenPanelResultListener *listener = [[WebOpenPanelResultListener alloc] initWithChooser:chooser];
 552     id delegate = [m_webView UIDelegate];
 553     if ([delegate respondsToSelector:@selector(webView:runOpenPanelForFileButtonWithResultListener:allowMultipleFiles:)])
 554         CallUIDelegate(m_webView, @selector(webView:runOpenPanelForFileButtonWithResultListener:allowMultipleFiles:), listener, allowMultipleFiles);
 555     else
 556         CallUIDelegate(m_webView, @selector(webView:runOpenPanelForFileButtonWithResultListener:), listener);
 557     [listener release];
 558     END_BLOCK_OBJC_EXCEPTIONS;
 559 }
 560
 561 KeyboardUIMode WebChromeClient::keyboardUIMode()
 562 {
 563     BEGIN_BLOCK_OBJC_EXCEPTIONS;
 564     return [m_webView _keyboardUIMode];
 565     END_BLOCK_OBJC_EXCEPTIONS;
 566     return KeyboardAccessDefault;
 567 }
 568
 569 NSResponder *WebChromeClient::firstResponder()
 570 {
 571     BEGIN_BLOCK_OBJC_EXCEPTIONS;
 572     return [[m_webView _UIDelegateForwarder] webViewFirstResponder:m_webView];
 573     END_BLOCK_OBJC_EXCEPTIONS;
 574     return nil;
 575 }
 576
 577 void WebChromeClient::makeFirstResponder(NSResponder *responder)
 578 {
 579     BEGIN_BLOCK_OBJC_EXCEPTIONS;
 580     [m_webView _pushPerformingProgrammaticFocus];
 581     [[m_webView _UIDelegateForwarder] webView:m_webView makeFirstResponder:responder];
 582     [m_webView _popPerformingProgrammaticFocus];
 583     END_BLOCK_OBJC_EXCEPTIONS;
 584 }
 585
 586 void WebChromeClient::willPopUpMenu(NSMenu *menu)
 587 {
 588     BEGIN_BLOCK_OBJC_EXCEPTIONS;
 589     CallUIDelegate(m_webView, @selector(webView:willPopupMenu:), menu);
 590     END_BLOCK_OBJC_EXCEPTIONS;
 591 }
 592
 593 bool WebChromeClient::shouldReplaceWithGeneratedFileForUpload(const String& path, String& generatedFilename)
 594 {
 595     NSString* filename;
 596     if (![[m_webView _UIDelegateForwarder] webView:m_webView shouldReplaceUploadFile:path usingGeneratedFilename:&filename])
 597         return false;
 598     generatedFilename = filename;
 599     return true;
 600 }
 601
 602 String WebChromeClient::generateReplacementFile(const String& path)
 603 {
 604     return [[m_webView _UIDelegateForwarder] webView:m_webView generateReplacementFile:path];
 605 }
 606
 607 void WebChromeClient::disableSuddenTermination()
 608 {
 609 #if !defined(BUILDING_ON_TIGER) && !defined(BUILDING_ON_LEOPARD)
 610     [[NSProcessInfo processInfo] disableSuddenTermination];
 611 #endif
 612 }
 613
 614 void WebChromeClient::enableSuddenTermination()
 615 {
 616 #if !defined(BUILDING_ON_TIGER) && !defined(BUILDING_ON_LEOPARD)
 617     [[NSProcessInfo processInfo] enableSuddenTermination];
 618 #endif
 619 }
 620
 621 @implementation WebOpenPanelResultListener
 622
 623 - (id)initWithChooser:(PassRefPtr<FileChooser>)chooser
 624 {
 625     self = [super init];
 626     if (!self)
 627         return nil;
 628     _chooser = chooser.releaseRef();
 629     return self;
 630 }
 631
 632 #ifndef NDEBUG
 633
 634 - (void)dealloc
 635 {
 636     ASSERT(!_chooser);
 637     [super dealloc];
 638 }
 639
 640 - (void)finalize
 641 {
 642     ASSERT(!_chooser);
 643     [super finalize];
 644 }
 645
 646 #endif
 647
 648 - (void)cancel
 649 {
 650     ASSERT(_chooser);
 651     if (!_chooser)
 652         return;
 653     _chooser->deref();
 654     _chooser = 0;
 655 }
 656
 657 - (void)chooseFilename:(NSString *)filename
 658 {
 659     ASSERT(_chooser);
 660     if (!_chooser)
 661         return;
 662     _chooser->chooseFile(filename);
 663     _chooser->deref();
 664     _chooser = 0;
 665 }
 666
 667 - (void)chooseFilenames:(NSArray *)filenames
 668 {
 669     ASSERT(_chooser);
 670     if (!_chooser)
 671         return;
 672     int count = [filenames count];
 673     Vector<String> names(count);
 674     for (int i = 0; i < count; i++)
 675         names[i] = [filenames objectAtIndex:i];
 676     _chooser->chooseFiles(names);
 677     _chooser->deref();
 678     _chooser = 0;
 679 }
 680
 681 @end