1 /*

     2  * Copyright (C) 2005, 2006, 2007 Apple Inc. All rights reserved.

     3  * Copyright (C) 2006 David Smith (catfish.man@gmail.com)

     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 "WebViewInternal.h"

    31 

    32 #import "DOMRangeInternal.h"

    33 #import "WebBackForwardList.h"

    34 #import "WebBackForwardListInternal.h"

    35 #import "WebBaseNetscapePluginView.h"

    36 #import "WebChromeClient.h"

    37 #import "WebContextMenuClient.h"

    38 #import "WebDOMOperationsPrivate.h"

    39 #import "WebDashboardRegion.h"

    40 #import "WebDataSourceInternal.h"

    41 #import "WebDefaultEditingDelegate.h"

    42 #import "WebDefaultPolicyDelegate.h"

    43 #import "WebDefaultScriptDebugDelegate.h"

    44 #import "WebDefaultUIDelegate.h"

    45 #import "WebDocument.h"

    46 #import "WebDocumentInternal.h"

    47 #import "WebDownload.h"

    48 #import "WebDownloadInternal.h"

    49 #import "WebDragClient.h"

    50 #import "WebDynamicScrollBarsView.h"

    51 #import "WebEditingDelegate.h"

    52 #import "WebEditorClient.h"

    53 #import "WebFormDelegatePrivate.h"

    54 #import "WebFrameBridge.h"

    55 #import "WebFrameInternal.h"

    56 #import "WebFrameViewInternal.h"

    57 #import "WebHTMLRepresentation.h"

    58 #import "WebHTMLViewInternal.h"

    59 #import "WebHistoryItemInternal.h"

    60 #import "WebIconDatabase.h"

    61 #import "WebIconDatabaseInternal.h"

    62 #import "WebInspectorClient.h"

    63 #import "WebKitErrors.h"

    64 #import "WebKitLogging.h"

    65 #import "WebKitNSStringExtras.h"

    66 #import "WebKitStatisticsPrivate.h"

    67 #import "WebKitSystemBits.h"

    68 #import "WebKitVersionChecks.h"

    69 #import "WebLocalizableStrings.h"

    70 #import "WebNSDataExtras.h"

    71 #import "WebNSDataExtrasPrivate.h"

    72 #import "WebNSDictionaryExtras.h"

    73 #import "WebNSEventExtras.h"

    74 #import "WebNSObjectExtras.h"

    75 #import "WebNSPasteboardExtras.h"

    76 #import "WebNSPrintOperationExtras.h"

    77 #import "WebNSURLExtras.h"

    78 #import "WebNSURLRequestExtras.h"

    79 #import "WebNSUserDefaultsExtras.h"

    80 #import "WebNSViewExtras.h"

    81 #import "WebPanelAuthenticationHandler.h"

    82 #import "WebPasteboardHelper.h"

    83 #import "WebPDFView.h"

    84 #import "WebPluginDatabase.h"

    85 #import "WebPolicyDelegate.h"

    86 #import "WebPreferenceKeysPrivate.h"

    87 #import "WebPreferencesPrivate.h"

    88 #import "WebScriptDebugDelegatePrivate.h"

    89 #import "WebScriptDebugServerPrivate.h"

    90 #import "WebUIDelegate.h"

    91 #import "WebUIDelegatePrivate.h"

    92 #import <CoreFoundation/CFSet.h>

    93 #import <Foundation/NSURLConnection.h>

    94 #import <JavaScriptCore/Assertions.h>

    95 #import <WebCore/Cache.h>

    96 #import <WebCore/ColorMac.h>

    97 #import <WebCore/Document.h>

    98 #import <WebCore/DocumentLoader.h>

    99 #import <WebCore/DragController.h>

   100 #import <WebCore/DragData.h>

   101 #import <WebCore/Editor.h>

   102 #import <WebCore/ExceptionHandlers.h>

   103 #import <WebCore/Frame.h>

   104 #import <WebCore/FrameLoader.h>

   105 #import <WebCore/FrameTree.h>

   106 #import <WebCore/HTMLNames.h>

   107 #import <WebCore/HistoryItem.h>

   108 #import <WebCore/Logging.h>

   109 #import <WebCore/MIMETypeRegistry.h>

   110 #import <WebCore/Page.h>

   111 #import <WebCore/PageCache.h>

   112 #import <WebCore/PlatformMouseEvent.h>

   113 #import <WebCore/ProgressTracker.h>

   114 #import <WebCore/SelectionController.h>

   115 #import <WebCore/Settings.h>

   116 #import <WebCore/TextResourceDecoder.h>

   117 #import <WebCore/WebCoreFrameBridge.h>

   118 #import <WebCore/WebCoreObjCExtras.h>

   119 #import <WebCore/WebCoreTextRenderer.h>

   120 #import <WebCore/WebCoreView.h>

   121 #import <WebKit/DOM.h>

   122 #import <WebKit/DOMExtensions.h>

   123 #import <WebKit/DOMPrivate.h>

   124 #import <WebKitSystemInterface.h>

   125 #import <mach-o/dyld.h>

   126 #import <objc/objc-runtime.h>

   127 #import <wtf/RefPtr.h>

   128 #import <wtf/HashTraits.h>

   129 

   130 using namespace WebCore;

   131 

   132 #if defined(__ppc__) || defined(__ppc64__)

   133 #define PROCESSOR "PPC"

   134 #elif defined(__i386__) || defined(__x86_64__)

   135 #define PROCESSOR "Intel"

   136 #else

   137 #error Unknown architecture

   138 #endif

   139 

   140 #define FOR_EACH_RESPONDER_SELECTOR(macro) \

   141 macro(alignCenter) \

   142 macro(alignJustified) \

   143 macro(alignLeft) \

   144 macro(alignRight) \

   145 macro(capitalizeWord) \

   146 macro(centerSelectionInVisibleArea) \

   147 macro(changeAttributes) \

   148 macro(changeColor) \

   149 macro(changeDocumentBackgroundColor) \

   150 macro(changeFont) \

   151 macro(checkSpelling) \

   152 macro(complete) \

   153 macro(copy) \

   154 macro(copyFont) \

   155 macro(cut) \

   156 macro(delete) \

   157 macro(deleteBackward) \

   158 macro(deleteBackwardByDecomposingPreviousCharacter) \

   159 macro(deleteForward) \

   160 macro(deleteToBeginningOfLine) \

   161 macro(deleteToBeginningOfParagraph) \

   162 macro(deleteToEndOfLine) \

   163 macro(deleteToEndOfParagraph) \

   164 macro(deleteWordBackward) \

   165 macro(deleteWordForward) \

   166 macro(ignoreSpelling) \

   167 macro(indent) \

   168 macro(insertBacktab) \

   169 macro(insertNewline) \

   170 macro(insertNewlineIgnoringFieldEditor) \

   171 macro(insertParagraphSeparator) \

   172 macro(insertTab) \

   173 macro(insertTabIgnoringFieldEditor) \

   174 macro(lowercaseWord) \

   175 macro(moveBackward) \

   176 macro(moveBackwardAndModifySelection) \

   177 macro(moveDown) \

   178 macro(moveDownAndModifySelection) \

   179 macro(moveForward) \

   180 macro(moveForwardAndModifySelection) \

   181 macro(moveLeft) \

   182 macro(moveLeftAndModifySelection) \

   183 macro(moveRight) \

   184 macro(moveRightAndModifySelection) \

   185 macro(moveToBeginningOfDocument) \

   186 macro(moveToBeginningOfDocumentAndModifySelection) \

   187 macro(moveToBeginningOfSentence) \

   188 macro(moveToBeginningOfSentenceAndModifySelection) \

   189 macro(moveToBeginningOfLine) \

   190 macro(moveToBeginningOfLineAndModifySelection) \

   191 macro(moveToBeginningOfParagraph) \

   192 macro(moveToBeginningOfParagraphAndModifySelection) \

   193 macro(moveToEndOfDocument) \

   194 macro(moveToEndOfDocumentAndModifySelection) \

   195 macro(moveToEndOfLine) \

   196 macro(moveToEndOfLineAndModifySelection) \

   197 macro(moveToEndOfParagraph) \

   198 macro(moveToEndOfParagraphAndModifySelection) \

   199 macro(moveToEndOfSentence) \

   200 macro(moveToEndOfSentenceAndModifySelection) \

   201 macro(moveUp) \

   202 macro(moveUpAndModifySelection) \

   203 macro(moveWordBackward) \

   204 macro(moveWordBackwardAndModifySelection) \

   205 macro(moveWordForward) \

   206 macro(moveWordForwardAndModifySelection) \

   207 macro(moveWordLeft) \

   208 macro(moveWordLeftAndModifySelection) \

   209 macro(moveWordRight) \

   210 macro(moveWordRightAndModifySelection) \

   211 macro(outdent) \

   212 macro(pageDown) \

   213 macro(pageUp) \

   214 macro(paste) \

   215 macro(pasteAsPlainText) \

   216 macro(pasteAsRichText) \

   217 macro(pasteFont) \

   218 macro(performFindPanelAction) \

   219 macro(scrollLineDown) \

   220 macro(scrollLineUp) \

   221 macro(scrollPageDown) \

   222 macro(scrollPageUp) \

   223 macro(scrollToBeginningOfDocument) \

   224 macro(scrollToEndOfDocument) \

   225 macro(selectAll) \

   226 macro(selectWord) \

   227 macro(selectSentence) \

   228 macro(selectLine) \

   229 macro(selectParagraph) \

   230 macro(showGuessPanel) \

   231 macro(startSpeaking) \

   232 macro(stopSpeaking) \

   233 macro(subscript) \

   234 macro(superscript) \

   235 macro(underline) \

   236 macro(unscript) \

   237 macro(uppercaseWord) \

   238 macro(yank) \

   239 macro(yankAndSelect) \

   240 

   241 #define WebKitOriginalTopPrintingMarginKey @"WebKitOriginalTopMargin"

   242 #define WebKitOriginalBottomPrintingMarginKey @"WebKitOriginalBottomMargin"

   243 

   244 static BOOL s_didSetCacheModel;

   245 static WebCacheModel s_cacheModel = WebCacheModelDocumentViewer;

   246 

   247 static BOOL applicationIsTerminating;

   248 static int pluginDatabaseClientCount = 0;

   249 

   250 @interface NSSpellChecker (AppKitSecretsIKnow)

   251 - (void)_preflightChosenSpellServer;

   252 @end

   253 

   254 @interface NSView (AppKitSecretsIKnow)

   255 - (NSView *)_hitTest:(NSPoint *)aPoint dragTypes:(NSSet *)types;

   256 - (void)_autoscrollForDraggingInfo:(id)dragInfo timeDelta:(NSTimeInterval)repeatDelta;

   257 - (BOOL)_shouldAutoscrollForDraggingInfo:(id)dragInfo;

   258 @end

   259 

   260 @interface NSWindow (AppKitSecretsIKnow) 

   261 - (id)_oldFirstResponderBeforeBecoming;

   262 @end

   263 

   264 @interface NSObject (ValidateWithoutDelegate)

   265 - (BOOL)validateUserInterfaceItemWithoutDelegate:(id <NSValidatedUserInterfaceItem>)item;

   266 @end

   267 

   268 @interface _WebSafeForwarder : NSObject

   269 {

   270     id target; // Non-retained. Don't retain delegates.

   271     id defaultTarget;

   272     BOOL catchExceptions;

   273 }

   274 - (id)initWithTarget:(id)target defaultTarget:(id)defaultTarget catchExceptions:(BOOL)catchExceptions;

   275 @end

   276 

   277 @interface WebViewPrivate : NSObject

   278 {

   279 @public

   280     Page* page;

   281     

   282     id UIDelegate;

   283     id UIDelegateForwarder;

   284     id resourceProgressDelegate;

   285     id downloadDelegate;

   286     id policyDelegate;

   287     id policyDelegateForwarder;

   288     id frameLoadDelegate;

   289     id frameLoadDelegateForwarder;

   290     id <WebFormDelegate> formDelegate;

   291     id editingDelegate;

   292     id editingDelegateForwarder;

   293     id scriptDebugDelegate;

   294     id scriptDebugDelegateForwarder;

   295 

   296     BOOL allowsUndo;

   297         

   298     float textSizeMultiplier;

   299 

   300     NSString *applicationNameForUserAgent;

   301     String* userAgent;

   302     BOOL userAgentOverridden;

   303     

   304     WebPreferences *preferences;

   305     BOOL useSiteSpecificSpoofing;

   306 

   307     NSWindow *hostWindow;

   308 

   309     int programmaticFocusCount;

   310     

   311     WebResourceDelegateImplementationCache resourceLoadDelegateImplementations;

   312     WebFrameLoadDelegateImplementationCache frameLoadDelegateImplementations;

   313 

   314     void *observationInfo;

   315     

   316     BOOL closed;

   317     BOOL shouldCloseWithWindow;

   318     BOOL mainFrameDocumentReady;

   319     BOOL drawsBackground;

   320     BOOL editable;

   321     BOOL tabKeyCyclesThroughElementsChanged;

   322     BOOL becomingFirstResponder;

   323     BOOL becomingFirstResponderFromOutside;

   324     BOOL hoverFeedbackSuspended;

   325     BOOL usesPageCache;

   326     BOOL catchesDelegateExceptions;

   327 

   328     NSColor *backgroundColor;

   329 

   330     NSString *mediaStyle;

   331     

   332     BOOL hasSpellCheckerDocumentTag;

   333     NSInteger spellCheckerDocumentTag;

   334 

   335     BOOL smartInsertDeleteEnabled;

   336         

   337     BOOL dashboardBehaviorAlwaysSendMouseEventsToAllWindows;

   338     BOOL dashboardBehaviorAlwaysSendActiveNullEventsToPlugIns;

   339     BOOL dashboardBehaviorAlwaysAcceptsFirstMouse;

   340     BOOL dashboardBehaviorAllowWheelScrolling;

   341     

   342     // WebKit has both a global plug-in database and a separate, per WebView plug-in database. Dashboard uses the per WebView database.

   343     WebPluginDatabase *pluginDatabase;

   344     

   345     HashMap<unsigned long, RetainPtr<id> >* identifierMap;

   346 }

   347 @end

   348 

   349 @interface WebView (WebFileInternal)

   350 + (void)_setCacheModel:(WebCacheModel)cacheModel;

   351 + (WebCacheModel)_cacheModel;

   352 - (WebFrame *)_selectedOrMainFrame;

   353 - (WebFrameBridge *)_bridgeForSelectedOrMainFrame;

   354 - (BOOL)_isLoading;

   355 - (WebFrameView *)_frameViewAtWindowPoint:(NSPoint)point;

   356 - (WebFrame *)_focusedFrame;

   357 + (void)_preflightSpellChecker;

   358 - (BOOL)_continuousCheckingAllowed;

   359 - (NSResponder *)_responderForResponderOperations;

   360 - (BOOL)_performTextSizingSelector:(SEL)sel withObject:(id)arg onTrackingDocs:(BOOL)doTrackingViews selForNonTrackingDocs:(SEL)testSel newScaleFactor:(float)newScaleFactor;

   361 - (void)_notifyTextSizeMultiplierChanged;

   362 @end

   363 

   364 @interface WebView (WebCallDelegateFunctions)

   365 @end

   366 

   367 NSString *WebElementDOMNodeKey =            @"WebElementDOMNode";

   368 NSString *WebElementFrameKey =              @"WebElementFrame";

   369 NSString *WebElementImageKey =              @"WebElementImage";

   370 NSString *WebElementImageAltStringKey =     @"WebElementImageAltString";

   371 NSString *WebElementImageRectKey =          @"WebElementImageRect";

   372 NSString *WebElementImageURLKey =           @"WebElementImageURL";

   373 NSString *WebElementIsSelectedKey =         @"WebElementIsSelected";

   374 NSString *WebElementLinkLabelKey =          @"WebElementLinkLabel";

   375 NSString *WebElementLinkTargetFrameKey =    @"WebElementTargetFrame";

   376 NSString *WebElementLinkTitleKey =          @"WebElementLinkTitle";

   377 NSString *WebElementLinkURLKey =            @"WebElementLinkURL";

   378 NSString *WebElementSpellingToolTipKey =    @"WebElementSpellingToolTip";

   379 NSString *WebElementTitleKey =              @"WebElementTitle";

   380 NSString *WebElementLinkIsLiveKey =         @"WebElementLinkIsLive";

   381 NSString *WebElementIsContentEditableKey =  @"WebElementIsContentEditableKey";

   382 

   383 NSString *WebViewProgressStartedNotification =          @"WebProgressStartedNotification";

   384 NSString *WebViewProgressEstimateChangedNotification =  @"WebProgressEstimateChangedNotification";

   385 NSString *WebViewProgressFinishedNotification =         @"WebProgressFinishedNotification";

   386 

   387 NSString * const WebViewDidBeginEditingNotification =         @"WebViewDidBeginEditingNotification";

   388 NSString * const WebViewDidChangeNotification =               @"WebViewDidChangeNotification";

   389 NSString * const WebViewDidEndEditingNotification =           @"WebViewDidEndEditingNotification";

   390 NSString * const WebViewDidChangeTypingStyleNotification =    @"WebViewDidChangeTypingStyleNotification";

   391 NSString * const WebViewDidChangeSelectionNotification =      @"WebViewDidChangeSelectionNotification";

   392 

   393 enum { WebViewVersion = 4 };

   394 

   395 #define timedLayoutSize 4096

   396 

   397 static NSMutableSet *schemesWithRepresentationsSet;

   398 

   399 NSString *_WebCanGoBackKey =            @"canGoBack";

   400 NSString *_WebCanGoForwardKey =         @"canGoForward";

   401 NSString *_WebEstimatedProgressKey =    @"estimatedProgress";

   402 NSString *_WebIsLoadingKey =            @"isLoading";

   403 NSString *_WebMainFrameIconKey =        @"mainFrameIcon";

   404 NSString *_WebMainFrameTitleKey =       @"mainFrameTitle";

   405 NSString *_WebMainFrameURLKey =         @"mainFrameURL";

   406 NSString *_WebMainFrameDocumentKey =    @"mainFrameDocument";

   407 

   408 @interface WebProgressItem : NSObject

   409 {

   410 @public

   411     long long bytesReceived;

   412     long long estimatedLength;

   413 }

   414 @end

   415 

   416 @implementation WebProgressItem

   417 @end

   418 

   419 static BOOL continuousSpellCheckingEnabled;

   420 #ifndef BUILDING_ON_TIGER

   421 static BOOL grammarCheckingEnabled;

   422 #endif

   423 

   424 @implementation WebViewPrivate

   425 

   426 #ifndef BUILDING_ON_TIGER

   427 + (void)initialize

   428 {

   429     WebCoreObjCFinalizeOnMainThread(self);

   430 }

   431 #endif

   432 

   433 - init 

   434 {

   435     self = [super init];

   436     if (!self)

   437         return nil;

   438     allowsUndo = YES;

   439     textSizeMultiplier = 1;

   440     dashboardBehaviorAllowWheelScrolling = YES;

   441     shouldCloseWithWindow = objc_collecting_enabled();

   442     continuousSpellCheckingEnabled = [[NSUserDefaults standardUserDefaults] boolForKey:WebContinuousSpellCheckingEnabled];

   443 

   444 #ifndef BUILDING_ON_TIGER

   445     grammarCheckingEnabled = [[NSUserDefaults standardUserDefaults] boolForKey:WebGrammarCheckingEnabled];

   446 #endif

   447     userAgent = new String;

   448     

   449     usesPageCache = YES;

   450     

   451     identifierMap = new HashMap<unsigned long, RetainPtr<id> >();

   452     pluginDatabaseClientCount++;

   453 

   454     return self;

   455 }

   456 

   457 - (void)dealloc

   458 {

   459     ASSERT(!page);

   460     ASSERT(!preferences);

   461 

   462     delete userAgent;

   463     delete identifierMap;

   464     

   465     [applicationNameForUserAgent release];

   466     [backgroundColor release];

   467     

   468     [hostWindow release];

   469 

   470     [policyDelegateForwarder release];

   471     [UIDelegateForwarder release];

   472     [frameLoadDelegateForwarder release];

   473     [editingDelegateForwarder release];

   474     [scriptDebugDelegateForwarder release];

   475     

   476     [mediaStyle release];

   477     

   478     [super dealloc];

   479 }

   480 

   481 - (void)finalize

   482 {

   483     ASSERT_MAIN_THREAD();

   484 

   485     delete userAgent;

   486     delete identifierMap;

   487 

   488     [super finalize];

   489 }

   490 

   491 @end

   492 

   493 @implementation WebView (AllWebViews)

   494 

   495 static CFSetCallBacks NonRetainingSetCallbacks = {

   496     0,

   497     NULL,

   498     NULL,

   499     CFCopyDescription,

   500     CFEqual,

   501     CFHash

   502 };

   503 

   504 static CFMutableSetRef allWebViewsSet;

   505 

   506 + (void)_makeAllWebViewsPerformSelector:(SEL)selector

   507 {

   508     if (!allWebViewsSet)

   509         return;

   510 

   511     [(NSMutableSet *)allWebViewsSet makeObjectsPerformSelector:selector];

   512 }

   513 

   514 - (void)_removeFromAllWebViewsSet

   515 {

   516     if (allWebViewsSet)

   517         CFSetRemoveValue(allWebViewsSet, self);

   518 }

   519 

   520 - (void)_addToAllWebViewsSet

   521 {

   522     if (!allWebViewsSet)

   523         allWebViewsSet = CFSetCreateMutable(NULL, 0, &NonRetainingSetCallbacks);

   524 

   525     CFSetSetValue(allWebViewsSet, self);

   526 }

   527 

   528 @end

   529 

   530 @implementation WebView (WebPrivate)

   531 

   532 #ifdef DEBUG_WIDGET_DRAWING

   533 static bool debugWidget = true;

   534 - (void)drawRect:(NSRect)rect

   535 {

   536     [[NSColor blueColor] set];

   537     NSRectFill (rect);

   538     

   539     NSRect htmlViewRect = [[[[self mainFrame] frameView] documentView] frame];

   540 

   541     if (debugWidget) {

   542         while (debugWidget) {

   543             sleep (1);

   544         }

   545     }

   546 

   547     NSLog (@"%s:   rect:  (%0.f,%0.f) %0.f %0.f, htmlViewRect:  (%0.f,%0.f) %0.f %0.f\n", 

   548         __PRETTY_FUNCTION__, rect.origin.x, rect.origin.y, rect.size.width, rect.size.height,

   549         htmlViewRect.origin.x, htmlViewRect.origin.y, htmlViewRect.size.width, htmlViewRect.size.height

   550     );

   551 

   552     [super drawRect:rect];

   553 }

   554 #endif

   555 

   556 + (BOOL)_developerExtrasEnabled

   557 {

   558     NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];

   559     if ([defaults boolForKey:@"DisableWebKitDeveloperExtras"])

   560         return NO;

   561 #ifdef NDEBUG

   562     BOOL enableDebugger = [defaults boolForKey:@"WebKitDeveloperExtras"];

   563     if (!enableDebugger)

   564         enableDebugger = [defaults boolForKey:@"IncludeDebugMenu"];

   565     return enableDebugger;

   566 #else

   567     return YES; // always enable in debug builds

   568 #endif

   569 }

   570 

   571 + (BOOL)_scriptDebuggerEnabled

   572 {

   573 #ifdef NDEBUG

   574     return [[NSUserDefaults standardUserDefaults] boolForKey:@"WebKitScriptDebuggerEnabled"];

   575 #else

   576     return YES; // always enable in debug builds

   577 #endif

   578 }

   579 

   580 + (NSArray *)_supportedMIMETypes

   581 {

   582     // Load the plug-in DB allowing plug-ins to install types.

   583     [WebPluginDatabase sharedDatabase];

   584     return [[WebFrameView _viewTypesAllowImageTypeOmission:NO] allKeys];

   585 }

   586 

   587 + (NSArray *)_supportedFileExtensions

   588 {

   589     NSMutableSet *extensions = [[NSMutableSet alloc] init];

   590     NSArray *MIMETypes = [self _supportedMIMETypes];

   591     NSEnumerator *enumerator = [MIMETypes objectEnumerator];

   592     NSString *MIMEType;

   593     while ((MIMEType = [enumerator nextObject]) != nil) {

   594         NSArray *extensionsForType = WKGetExtensionsForMIMEType(MIMEType);

   595         if (extensionsForType) {

   596             [extensions addObjectsFromArray:extensionsForType];

   597         }

   598     }

   599     NSArray *uniqueExtensions = [extensions allObjects];

   600     [extensions release];

   601     return uniqueExtensions;

   602 }

   603 

   604 + (BOOL)_viewClass:(Class *)vClass andRepresentationClass:(Class *)rClass forMIMEType:(NSString *)MIMEType;

   605 {

   606     MIMEType = [MIMEType lowercaseString];

   607     Class viewClass = [[WebFrameView _viewTypesAllowImageTypeOmission:YES] _webkit_objectForMIMEType:MIMEType];

   608     Class repClass = [[WebDataSource _repTypesAllowImageTypeOmission:YES] _webkit_objectForMIMEType:MIMEType];

   609     

   610     if (!viewClass || !repClass || [[WebPDFView supportedMIMETypes] containsObject:MIMEType]) {

   611         // Our optimization to avoid loading the plug-in DB and image types for the HTML case failed.

   612         // Load the plug-in DB allowing plug-ins to install types.

   613         [WebPluginDatabase sharedDatabase];

   614             

   615         // Load the image types and get the view class and rep class. This should be the fullest picture of all handled types.

   616         viewClass = [[WebFrameView _viewTypesAllowImageTypeOmission:NO] _webkit_objectForMIMEType:MIMEType];

   617         repClass = [[WebDataSource _repTypesAllowImageTypeOmission:NO] _webkit_objectForMIMEType:MIMEType];

   618     }

   619     

   620     if (viewClass && repClass) {

   621         // Special-case WebHTMLView for text types that shouldn't be shown.

   622         if (viewClass == [WebHTMLView class] &&

   623             repClass == [WebHTMLRepresentation class] &&

   624             [[WebHTMLView unsupportedTextMIMETypes] containsObject:MIMEType]) {

   625             return NO;

   626         }

   627         if (vClass)

   628             *vClass = viewClass;

   629         if (rClass)

   630             *rClass = repClass;

   631         return YES;

   632     }

   633     

   634     return NO;

   635 }

   636 

   637 - (BOOL)_viewClass:(Class *)vClass andRepresentationClass:(Class *)rClass forMIMEType:(NSString *)MIMEType;

   638 {

   639     if ([[self class] _viewClass:vClass andRepresentationClass:rClass forMIMEType:MIMEType])

   640         return YES;

   641 

   642     if (_private->pluginDatabase) {

   643         WebBasePluginPackage *pluginPackage = [_private->pluginDatabase pluginForMIMEType:MIMEType];

   644         if (pluginPackage) {

   645             if (vClass)

   646                 *vClass = [WebHTMLView class];

   647             if (rClass)

   648                 *rClass = [WebHTMLRepresentation class];

   649             return YES;

   650         }

   651     }

   652     

   653     return NO;

   654 }

   655 

   656 + (void)_setAlwaysUseATSU:(BOOL)f

   657 {

   658     WebCoreSetAlwaysUseATSU(f);

   659 }

   660 

   661 + (BOOL)canShowFile:(NSString *)path

   662 {

   663     return [[self class] canShowMIMEType:[WebView _MIMETypeForFile:path]];

   664 }

   665 

   666 + (NSString *)suggestedFileExtensionForMIMEType:(NSString *)type

   667 {

   668     return WKGetPreferredExtensionForMIMEType(type);

   669 }

   670 

   671 - (BOOL)_isClosed

   672 {

   673     if (!_private || _private->closed)

   674         return YES;

   675     return NO;

   676 }

   677 

   678 - (void)_close

   679 {

   680     if (!_private || _private->closed)

   681         return;

   682 

   683     FrameLoader* mainFrameLoader = [[self mainFrame] _frameLoader];

   684     if (mainFrameLoader)

   685         mainFrameLoader->detachFromParent();

   686 

   687     [self _removeFromAllWebViewsSet];

   688     [self setGroupName:nil];

   689     [self setHostWindow:nil];

   690 

   691     [self setDownloadDelegate:nil];

   692     [self setEditingDelegate:nil];

   693     [self setFrameLoadDelegate:nil];

   694     [self setPolicyDelegate:nil];

   695     [self setResourceLoadDelegate:nil];

   696     [self setScriptDebugDelegate:nil];

   697     [self setUIDelegate:nil];

   698     

   699     // setHostWindow:nil must be called before this value is set (see 5408186)

   700     _private->closed = YES;

   701 

   702     // To avoid leaks, call removeDragCaret in case it wasn't called after moveDragCaretToPoint.

   703     [self removeDragCaret];

   704 

   705     // Deleteing the WebCore::Page will clear the page cache so we call destroy on 

   706     // all the plug-ins in the page cache to break any retain cycles.

   707     // See comment in HistoryItem::releaseAllPendingPageCaches() for more information.

   708     delete _private->page;

   709     _private->page = 0;

   710 

   711     if (_private->hasSpellCheckerDocumentTag) {

   712         [[NSSpellChecker sharedSpellChecker] closeSpellDocumentWithTag:_private->spellCheckerDocumentTag];

   713         _private->hasSpellCheckerDocumentTag = NO;

   714     }

   715     

   716     [[NSNotificationCenter defaultCenter] removeObserver:self];

   717 

   718     [WebPreferences _removeReferenceForIdentifier:[self preferencesIdentifier]];

   719 

   720     WebPreferences *preferences = _private->preferences;

   721     _private->preferences = nil;

   722     [preferences didRemoveFromWebView];

   723     [preferences release];

   724 

   725     pluginDatabaseClientCount--;

   726     

   727     // Make sure to close both sets of plug-ins databases because plug-ins need an opportunity to clean up files, etc.

   728     

   729     // Unload the WebView local plug-in database. 

   730     if (_private->pluginDatabase) {

   731         [_private->pluginDatabase close];

   732         [_private->pluginDatabase release];

   733         _private->pluginDatabase = nil;

   734     }

   735     

   736     // Keep the global plug-in database active until the app terminates to avoid having to reload plug-in bundles.

   737     if (!pluginDatabaseClientCount && applicationIsTerminating)

   738         [WebPluginDatabase closeSharedDatabase];

   739 }

   740 

   741 + (NSString *)_MIMETypeForFile:(NSString *)path

   742 {

   743     NSString *extension = [path pathExtension];

   744     NSString *MIMEType = nil;

   745 

   746     // Get the MIME type from the extension.

   747     if ([extension length] != 0) {

   748         MIMEType = WKGetMIMETypeForExtension(extension);

   749     }

   750 

   751     // If we can't get a known MIME type from the extension, sniff.

   752     if ([MIMEType length] == 0 || [MIMEType isEqualToString:@"application/octet-stream"]) {

   753         NSFileHandle *handle = [NSFileHandle fileHandleForReadingAtPath:path];

   754         NSData *data = [handle readDataOfLength:WEB_GUESS_MIME_TYPE_PEEK_LENGTH];

   755         [handle closeFile];

   756         if ([data length] != 0) {

   757             MIMEType = [data _webkit_guessedMIMEType];

   758         }

   759         if ([MIMEType length] == 0) {

   760             MIMEType = @"application/octet-stream";

   761         }

   762     }

   763 

   764     return MIMEType;

   765 }

   766 

   767 - (WebDownload *)_downloadURL:(NSURL *)URL

   768 {

   769     ASSERT(URL);

   770     

   771     NSURLRequest *request = [[NSURLRequest alloc] initWithURL:URL];

   772     WebDownload *download = [WebDownload _downloadWithRequest:request

   773                                                      delegate:_private->downloadDelegate

   774                                                     directory:nil];

   775     [request release];

   776     

   777     return download;

   778 }

   779 

   780 - (WebView *)_openNewWindowWithRequest:(NSURLRequest *)request

   781 {

   782     WebView *newWindowWebView = CallUIDelegate(self, @selector(webView:createWebViewWithRequest:), request);

   783     if (!newWindowWebView)

   784         return nil;

   785 

   786     CallUIDelegate(newWindowWebView, @selector(webViewShow:));

   787     return newWindowWebView;

   788 }

   789 

   790 - (WebCore::Page*)page

   791 {

   792     return _private->page;

   793 }

   794 

   795 - (NSMenu *)_menuForElement:(NSDictionary *)element defaultItems:(NSArray *)items

   796 {

   797     NSArray *defaultMenuItems = [[WebDefaultUIDelegate sharedUIDelegate] webView:self contextMenuItemsForElement:element defaultMenuItems:items];

   798 

   799     NSArray *menuItems = CallUIDelegate(self, @selector(webView:contextMenuItemsForElement:defaultMenuItems:), element, defaultMenuItems);

   800     if (!menuItems)

   801         return nil;

   802 

   803     unsigned count = [menuItems count];

   804     if (!count)

   805         return nil;

   806 

   807     NSMenu *menu = [[NSMenu alloc] init];

   808     for (unsigned i = 0; i < count; i++)

   809         [menu addItem:[menuItems objectAtIndex:i]];

   810 

   811     return [menu autorelease];

   812 }

   813 

   814 - (void)_mouseDidMoveOverElement:(NSDictionary *)dictionary modifierFlags:(NSUInteger)modifierFlags

   815 {

   816     // We originally intended to call this delegate method sometimes with a nil dictionary, but due to

   817     // a bug dating back to WebKit 1.0 this delegate was never called with nil! Unfortunately we can't

   818     // start calling this with nil since it will break Adobe Help Viewer, and possibly other clients.

   819     if (!dictionary)

   820         return;

   821     CallUIDelegate(self, @selector(webView:mouseDidMoveOverElement:modifierFlags:), dictionary, modifierFlags);

   822 }

   823 

   824 - (void)_loadBackForwardListFromOtherView:(WebView *)otherView

   825 {

   826     if (!_private->page)

   827         return;

   828     

   829     if (!otherView->_private->page)

   830         return;

   831     

   832     // It turns out the right combination of behavior is done with the back/forward load

   833     // type.  (See behavior matrix at the top of WebFramePrivate.)  So we copy all the items

   834     // in the back forward list, and go to the current one.

   835 

   836     BackForwardList* backForwardList = _private->page->backForwardList();

   837     ASSERT(!backForwardList->currentItem()); // destination list should be empty

   838 

   839     BackForwardList* otherBackForwardList = otherView->_private->page->backForwardList();

   840     if (!otherBackForwardList->currentItem())

   841         return; // empty back forward list, bail

   842     

   843     HistoryItem* newItemToGoTo = 0;

   844 

   845     int lastItemIndex = otherBackForwardList->forwardListCount();

   846     for (int i = -otherBackForwardList->backListCount(); i <= lastItemIndex; ++i) {

   847         if (i == 0) {

   848             // If this item is showing , save away its current scroll and form state,

   849             // since that might have changed since loading and it is normally not saved

   850             // until we leave that page.

   851             otherView->_private->page->mainFrame()->loader()->saveDocumentAndScrollState();

   852         }

   853         RefPtr<HistoryItem> newItem = otherBackForwardList->itemAtIndex(i)->copy();

   854         if (i == 0) 

   855             newItemToGoTo = newItem.get();

   856         backForwardList->addItem(newItem.release());

   857     }

   858     

   859     ASSERT(newItemToGoTo);

   860     _private->page->goToItem(newItemToGoTo, FrameLoadTypeIndexedBackForward);

   861 }

   862 

   863 - (void)_setFormDelegate: (id<WebFormDelegate>)delegate

   864 {

   865     _private->formDelegate = delegate;

   866 }

   867 

   868 - (id<WebFormDelegate>)_formDelegate

   869 {

   870     return _private->formDelegate;

   871 }

   872 

   873 - (BOOL)_needsAdobeFrameReloadingQuirk

   874 {

   875     static BOOL checked = NO;

   876     static BOOL needsQuirk = NO;

   877 

   878     if (checked)

   879         return needsQuirk;

   880 

   881     needsQuirk = WKAppVersionCheckLessThan(@"com.adobe.Acrobat", -1, 9.0)

   882         || WKAppVersionCheckLessThan(@"com.adobe.Acrobat.Pro", -1, 9.0)

   883         || WKAppVersionCheckLessThan(@"com.adobe.Reader", -1, 9.0)

   884         || WKAppVersionCheckLessThan(@"com.adobe.distiller", -1, 9.0)

   885         || WKAppVersionCheckLessThan(@"com.adobe.Contribute", -1, 4.2)

   886         || WKAppVersionCheckLessThan(@"com.adobe.dreamweaver-9.0", -1, 9.1)

   887         || WKAppVersionCheckLessThan(@"com.macromedia.fireworks", -1, 9.1)

   888         || WKAppVersionCheckLessThan(@"com.adobe.InCopy", -1, 5.1)

   889         || WKAppVersionCheckLessThan(@"com.adobe.InDesign", -1, 5.1)

   890         || WKAppVersionCheckLessThan(@"com.adobe.Soundbooth", -1, 2);

   891 

   892     return needsQuirk;

   893 }

   894 

   895 - (void)_preferencesChangedNotification:(NSNotification *)notification

   896 {

   897     WebPreferences *preferences = (WebPreferences *)[notification object];

   898     ASSERT(preferences == [self preferences]);

   899 

   900     if (!_private->userAgentOverridden)

   901         *_private->userAgent = String();

   902 

   903     // Cache this value so we don't have to read NSUserDefaults on each page load

   904     _private->useSiteSpecificSpoofing = [preferences _useSiteSpecificSpoofing];

   905 

   906     // Update corresponding WebCore Settings object.

   907     if (!_private->page)

   908         return;

   909     

   910     Settings* settings = _private->page->settings();

   911     

   912     settings->setCursiveFontFamily([preferences cursiveFontFamily]);

   913     settings->setDefaultFixedFontSize([preferences defaultFixedFontSize]);

   914     settings->setDefaultFontSize([preferences defaultFontSize]);

   915     settings->setDefaultTextEncodingName([preferences defaultTextEncodingName]);

   916     settings->setFantasyFontFamily([preferences fantasyFontFamily]);

   917     settings->setFixedFontFamily([preferences fixedFontFamily]);

   918     settings->setForceFTPDirectoryListings([preferences _forceFTPDirectoryListings]);

   919     settings->setFTPDirectoryTemplatePath([preferences _ftpDirectoryTemplatePath]);

   920     settings->setJavaEnabled([preferences isJavaEnabled]);

   921     settings->setJavaScriptEnabled([preferences isJavaScriptEnabled]);

   922     settings->setJavaScriptCanOpenWindowsAutomatically([preferences javaScriptCanOpenWindowsAutomatically]);

   923     settings->setMinimumFontSize([preferences minimumFontSize]);

   924     settings->setMinimumLogicalFontSize([preferences minimumLogicalFontSize]);

   925     settings->setPluginsEnabled([preferences arePlugInsEnabled]);

   926     settings->setPrivateBrowsingEnabled([preferences privateBrowsingEnabled]);

   927     settings->setSansSerifFontFamily([preferences sansSerifFontFamily]);

   928     settings->setSerifFontFamily([preferences serifFontFamily]);

   929     settings->setStandardFontFamily([preferences standardFontFamily]);

   930     settings->setLoadsImagesAutomatically([preferences loadsImagesAutomatically]);

   931     settings->setShouldPrintBackgrounds([preferences shouldPrintBackgrounds]);

   932     settings->setTextAreasAreResizable([preferences textAreasAreResizable]);

   933     settings->setShrinksStandaloneImagesToFit([preferences shrinksStandaloneImagesToFit]);

   934     settings->setEditableLinkBehavior(core([preferences editableLinkBehavior]));

   935     settings->setDOMPasteAllowed([preferences isDOMPasteAllowed]);

   936     settings->setUsesPageCache([self usesPageCache]);

   937     settings->setShowsURLsInToolTips([preferences showsURLsInToolTips]);

   938     settings->setDeveloperExtrasEnabled([WebView _developerExtrasEnabled]);

   939     if ([preferences userStyleSheetEnabled]) {

   940         NSString* location = [[preferences userStyleSheetLocation] _web_originalDataAsString];

   941         settings->setUserStyleSheetLocation([NSURL URLWithString:(location ? location : @"")]);

   942     } else

   943         settings->setUserStyleSheetLocation([NSURL URLWithString:@""]);

   944     settings->setNeedsAdobeFrameReloadingQuirk([self _needsAdobeFrameReloadingQuirk]);

   945 }

   946 

   947 static inline IMP getMethod(id o, SEL s)

   948 {

   949     return [o respondsToSelector:s] ? [o methodForSelector:s] : 0;

   950 }

   951 

   952 - (void)_cacheResourceLoadDelegateImplementations

   953 {

   954     WebResourceDelegateImplementationCache *cache = &_private->resourceLoadDelegateImplementations;

   955     id delegate = _private->resourceProgressDelegate;

   956 

   957     cache->didCancelAuthenticationChallengeFunc = getMethod(delegate, @selector(webView:resource:didReceiveAuthenticationChallenge:fromDataSource:));

   958     cache->didFailLoadingWithErrorFromDataSourceFunc = getMethod(delegate, @selector(webView:resource:didFailLoadingWithError:fromDataSource:));

   959     cache->didFinishLoadingFromDataSourceFunc = getMethod(delegate, @selector(webView:resource:didFinishLoadingFromDataSource:));

   960     cache->didLoadResourceFromMemoryCacheFunc = getMethod(delegate, @selector(webView:didLoadResourceFromMemoryCache:response:length:fromDataSource:));

   961     cache->didReceiveAuthenticationChallengeFunc = getMethod(delegate, @selector(webView:resource:didReceiveAuthenticationChallenge:fromDataSource:));

   962     cache->didReceiveContentLengthFunc = getMethod(delegate, @selector(webView:resource:didReceiveContentLength:fromDataSource:));

   963     cache->didReceiveResponseFunc = getMethod(delegate, @selector(webView:resource:didReceiveResponse:fromDataSource:));

   964     cache->identifierForRequestFunc = getMethod(delegate, @selector(webView:identifierForInitialRequest:fromDataSource:));

   965     cache->plugInFailedWithErrorFunc = getMethod(delegate, @selector(webView:plugInFailedWithError:dataSource:));

   966     cache->willCacheResponseFunc = getMethod(delegate, @selector(webView:resource:willCacheResponse:fromDataSource:));

   967     cache->willSendRequestFunc = getMethod(delegate, @selector(webView:resource:willSendRequest:redirectResponse:fromDataSource:));

   968 }

   969 

   970 WebResourceDelegateImplementationCache WebViewGetResourceLoadDelegateImplementations(WebView *webView)

   971 {

   972     return webView->_private->resourceLoadDelegateImplementations;

   973 }

   974 

   975 - (void)_cacheFrameLoadDelegateImplementations

   976 {

   977     WebFrameLoadDelegateImplementationCache *cache = &_private->frameLoadDelegateImplementations;

   978     id delegate = _private->frameLoadDelegate;

   979 

   980     cache->didCancelClientRedirectForFrameFunc = getMethod(delegate, @selector(webView:didCancelClientRedirectForFrame:));

   981     cache->didChangeLocationWithinPageForFrameFunc = getMethod(delegate, @selector(webView:didChangeLocationWithinPageForFrame:));

   982     cache->didClearWindowObjectForFrameFunc = getMethod(delegate, @selector(webView:didClearWindowObject:forFrame:));

   983     cache->didCommitLoadForFrameFunc = getMethod(delegate, @selector(webView:didCommitLoadForFrame:));

   984     cache->didFailLoadWithErrorForFrameFunc = getMethod(delegate, @selector(webView:didFailLoadWithError:forFrame:));

   985     cache->didFailProvisionalLoadWithErrorForFrameFunc = getMethod(delegate, @selector(webView:didFailProvisionalLoadWithError:forFrame:));

   986     cache->didFinishDocumentLoadForFrameFunc = getMethod(delegate, @selector(webView:didFinishDocumentLoadForFrame:));

   987     cache->didFinishLoadForFrameFunc = getMethod(delegate, @selector(webView:didFinishLoadForFrame:));

   988     cache->didFirstLayoutInFrameFunc = getMethod(delegate, @selector(webView:didFirstLayoutInFrame:));

   989     cache->didHandleOnloadEventsForFrameFunc = getMethod(delegate, @selector(webView:didHandleOnloadEventsForFrame:));

   990     cache->didReceiveIconForFrameFunc = getMethod(delegate, @selector(webView:didReceiveIcon:forFrame:));

   991     cache->didReceiveServerRedirectForProvisionalLoadForFrameFunc = getMethod(delegate, @selector(webView:didReceiveServerRedirectForProvisionalLoadForFrame:));

   992     cache->didReceiveTitleForFrameFunc = getMethod(delegate, @selector(webView:didReceiveTitle:forFrame:));

   993     cache->didStartProvisionalLoadForFrameFunc = getMethod(delegate, @selector(webView:didStartProvisionalLoadForFrame:));

   994     cache->willCloseFrameFunc = getMethod(delegate, @selector(webView:willCloseFrame:));

   995     cache->willPerformClientRedirectToURLDelayFireDateForFrameFunc = getMethod(delegate, @selector(webView:willPerformClientRedirectToURL:delay:fireDate:forFrame:));

   996     cache->windowScriptObjectAvailableFunc = getMethod(delegate, @selector(webView:windowScriptObjectAvailable:));

   997 }

   998 

   999 WebFrameLoadDelegateImplementationCache WebViewGetFrameLoadDelegateImplementations(WebView *webView)

  1000 {

  1001     return webView->_private->frameLoadDelegateImplementations;

  1002 }

  1003 

  1004 - (id)_policyDelegateForwarder

  1005 {

  1006     if (!_private->policyDelegateForwarder)

  1007         _private->policyDelegateForwarder = [[_WebSafeForwarder alloc] initWithTarget:_private->policyDelegate defaultTarget:[WebDefaultPolicyDelegate sharedPolicyDelegate] catchExceptions:_private->catchesDelegateExceptions];

  1008     return _private->policyDelegateForwarder;

  1009 }

  1010 

  1011 - (id)_UIDelegateForwarder

  1012 {

  1013     if (!_private->UIDelegateForwarder)

  1014         _private->UIDelegateForwarder = [[_WebSafeForwarder alloc] initWithTarget:_private->UIDelegate defaultTarget:[WebDefaultUIDelegate sharedUIDelegate] catchExceptions:_private->catchesDelegateExceptions];

  1015     return _private->UIDelegateForwarder;

  1016 }

  1017 

  1018 - (id)_editingDelegateForwarder

  1019 {

  1020     // This can be called during window deallocation by QTMovieView in the QuickTime Cocoa Plug-in.

  1021     // Not sure if that is a bug or not.

  1022     if (!_private)

  1023         return nil;

  1024 

  1025     if (!_private->editingDelegateForwarder)

  1026         _private->editingDelegateForwarder = [[_WebSafeForwarder alloc] initWithTarget:_private->editingDelegate defaultTarget:[WebDefaultEditingDelegate sharedEditingDelegate] catchExceptions:_private->catchesDelegateExceptions];

  1027     return _private->editingDelegateForwarder;

  1028 }

  1029 

  1030 - (id)_scriptDebugDelegateForwarder

  1031 {

  1032     if (!_private->scriptDebugDelegateForwarder)

  1033         _private->scriptDebugDelegateForwarder = [[_WebSafeForwarder alloc] initWithTarget:_private->scriptDebugDelegate defaultTarget:[WebDefaultScriptDebugDelegate sharedScriptDebugDelegate] catchExceptions:_private->catchesDelegateExceptions];

  1034     return _private->scriptDebugDelegateForwarder;

  1035 }

  1036 

  1037 - (void)_closeWindow

  1038 {

  1039     [[self _UIDelegateForwarder] webViewClose:self];

  1040 }

  1041 

  1042 + (void)_unregisterViewClassAndRepresentationClassForMIMEType:(NSString *)MIMEType;

  1043 {

  1044     [[WebFrameView _viewTypesAllowImageTypeOmission:NO] removeObjectForKey:MIMEType];

  1045     [[WebDataSource _repTypesAllowImageTypeOmission:NO] removeObjectForKey:MIMEType];

  1046     

  1047     // FIXME: We also need to maintain MIMEType registrations (which can be dynamically changed)

  1048     // in the WebCore MIMEType registry.  For now we're doing this in a safe, limited manner

  1049     // to fix <rdar://problem/5372989> - a future revamping of the entire system is neccesary for future robustness

  1050     MIMETypeRegistry::getSupportedNonImageMIMETypes().remove(MIMEType);

  1051 }

  1052 

  1053 + (void)_registerViewClass:(Class)viewClass representationClass:(Class)representationClass forURLScheme:(NSString *)URLScheme;

  1054 {

  1055     NSString *MIMEType = [self _generatedMIMETypeForURLScheme:URLScheme];

  1056     [self registerViewClass:viewClass representationClass:representationClass forMIMEType:MIMEType];

  1057 

  1058     // FIXME: We also need to maintain MIMEType registrations (which can be dynamically changed)

  1059     // in the WebCore MIMEType registry.  For now we're doing this in a safe, limited manner

  1060     // to fix <rdar://problem/5372989> - a future revamping of the entire system is neccesary for future robustness

  1061     if ([viewClass class] == [WebHTMLView class])

  1062         MIMETypeRegistry::getSupportedNonImageMIMETypes().add(MIMEType);

  1063     

  1064     // This is used to make _representationExistsForURLScheme faster.

  1065     // Without this set, we'd have to create the MIME type each time.

  1066     if (schemesWithRepresentationsSet == nil) {

  1067         schemesWithRepresentationsSet = [[NSMutableSet alloc] init];

  1068     }

  1069     [schemesWithRepresentationsSet addObject:[[[URLScheme lowercaseString] copy] autorelease]];

  1070 }

  1071 

  1072 + (NSString *)_generatedMIMETypeForURLScheme:(NSString *)URLScheme

  1073 {

  1074     return [@"x-apple-web-kit/" stringByAppendingString:[URLScheme lowercaseString]];

  1075 }

  1076 

  1077 + (BOOL)_representationExistsForURLScheme:(NSString *)URLScheme

  1078 {

  1079     return [schemesWithRepresentationsSet containsObject:[URLScheme lowercaseString]];

  1080 }

  1081 

  1082 + (BOOL)_canHandleRequest:(NSURLRequest *)request

  1083 {

  1084     // FIXME: If <rdar://problem/5217309> gets fixed, this check can be removed

  1085     if (!request)

  1086         return NO;

  1087 

  1088     if ([NSURLConnection canHandleRequest:request])

  1089         return YES;

  1090 

  1091     NSString *scheme = [[request URL] scheme];

  1092 

  1093     if ([self _representationExistsForURLScheme:scheme])

  1094         return YES;

  1095         

  1096     return ([scheme _webkit_isCaseInsensitiveEqualToString:@"applewebdata"]);

  1097 }

  1098 

  1099 + (NSString *)_decodeData:(NSData *)data

  1100 {

  1101     HTMLNames::init(); // this method is used for importing bookmarks at startup, so HTMLNames are likely to be uninitialized yet

  1102     RefPtr<TextResourceDecoder> decoder = new TextResourceDecoder("text/html"); // bookmark files are HTML

  1103     String result = decoder->decode(static_cast<const char*>([data bytes]), [data length]);

  1104     result += decoder->flush();

  1105     return result;

  1106 }

  1107 

  1108 - (void)_pushPerformingProgrammaticFocus

  1109 {

  1110     _private->programmaticFocusCount++;

  1111 }

  1112 

  1113 - (void)_popPerformingProgrammaticFocus

  1114 {

  1115     _private->programmaticFocusCount--;

  1116 }

  1117 

  1118 - (BOOL)_isPerformingProgrammaticFocus

  1119 {

  1120     return _private->programmaticFocusCount != 0;

  1121 }

  1122 

  1123 - (void)_didChangeValueForKey: (NSString *)key

  1124 {

  1125     LOG (Bindings, "calling didChangeValueForKey: %@", key);

  1126     [self didChangeValueForKey: key];

  1127 }

  1128 

  1129 - (void)_willChangeValueForKey: (NSString *)key

  1130 {

  1131     LOG (Bindings, "calling willChangeValueForKey: %@", key);

  1132     [self willChangeValueForKey: key];

  1133 }

  1134 

  1135 + (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key {