1 /*

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

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

     4  * Copyright (C) 2010 Igalia S.L

     5  *

     6  * Redistribution and use in source and binary forms, with or without

     7  * modification, are permitted provided that the following conditions

     8  * are met:

     9  *

    10  * 1.  Redistributions of source code must retain the above copyright

    11  *     notice, this list of conditions and the following disclaimer. 

    12  * 2.  Redistributions in binary form must reproduce the above copyright

    13  *     notice, this list of conditions and the following disclaimer in the

    14  *     documentation and/or other materials provided with the distribution. 

    15  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

    16  *     its contributors may be used to endorse or promote products derived

    17  *     from this software without specific prior written permission. 

    18  *

    19  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

    20  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

    21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    22  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

    23  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

    26  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

    28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    29  */

    30 

    31 #import "WebViewInternal.h"

    32 #import "WebViewData.h"

    33 

    34 #import "DOMCSSStyleDeclarationInternal.h"

    35 #import "DOMNodeInternal.h"

    36 #import "DOMRangeInternal.h"

    37 #import "WebBackForwardListInternal.h"

    38 #import "WebBaseNetscapePluginView.h"

    39 #import "WebCache.h"

    40 #import "WebChromeClient.h"

    41 #import "WebContextMenuClient.h"

    42 #import "WebDOMOperationsPrivate.h"

    43 #import "WebDataSourceInternal.h"

    44 #import "WebDatabaseManagerInternal.h"

    45 #import "WebDefaultEditingDelegate.h"

    46 #import "WebDefaultPolicyDelegate.h"

    47 #import "WebDefaultUIDelegate.h"

    48 #import "WebDelegateImplementationCaching.h"

    49 #import "WebDocument.h"

    50 #import "WebDocumentInternal.h"

    51 #import "WebDownload.h"

    52 #import "WebDownloadInternal.h"

    53 #import "WebDragClient.h"

    54 #import "WebDynamicScrollBarsViewInternal.h"

    55 #import "WebEditingDelegate.h"

    56 #import "WebEditorClient.h"

    57 #import "WebFormDelegatePrivate.h"

    58 #import "WebFrameInternal.h"

    59 #import "WebFrameViewInternal.h"

    60 #import "WebGeolocationControllerClient.h"

    61 #import "WebGeolocationPositionInternal.h"

    62 #import "WebHTMLRepresentation.h"

    63 #import "WebHTMLViewInternal.h"

    64 #import "WebHistoryItemInternal.h"

    65 #import "WebIconDatabaseInternal.h"

    66 #import "WebInspector.h"

    67 #import "WebInspectorClient.h"

    68 #import "WebKitErrors.h"

    69 #import "WebKitLogging.h"

    70 #import "WebKitNSStringExtras.h"

    71 #import "WebKitStatisticsPrivate.h"

    72 #import "WebKitSystemBits.h"

    73 #import "WebKitVersionChecks.h"

    74 #import "WebLocalizableStrings.h"

    75 #import "WebNSDataExtras.h"

    76 #import "WebNSDataExtrasPrivate.h"

    77 #import "WebNSDictionaryExtras.h"

    78 #import "WebNSEventExtras.h"

    79 #import "WebNSObjectExtras.h"

    80 #import "WebNSPasteboardExtras.h"

    81 #import "WebNSPrintOperationExtras.h"

    82 #import "WebNSURLExtras.h"

    83 #import "WebNSURLRequestExtras.h"

    84 #import "WebNSUserDefaultsExtras.h"

    85 #import "WebNSViewExtras.h"

    86 #import "WebNodeHighlight.h"

    87 #import "WebPDFView.h"

    88 #import "WebPanelAuthenticationHandler.h"

    89 #import "WebPasteboardHelper.h"

    90 #import "WebPlatformStrategies.h"

    91 #import "WebPluginDatabase.h"

    92 #import "WebPluginHalterClient.h"

    93 #import "WebPolicyDelegate.h"

    94 #import "WebPreferenceKeysPrivate.h"

    95 #import "WebPreferencesPrivate.h"

    96 #import "WebScriptDebugDelegate.h"

    97 #import "WebScriptWorldInternal.h"

    98 #import "WebSystemInterface.h"

    99 #import "WebTextCompletionController.h"

   100 #import "WebTextIterator.h"

   101 #import "WebUIDelegate.h"

   102 #import "WebUIDelegatePrivate.h"

   103 #import "WebVideoFullscreenController.h"

   104 #import <CoreFoundation/CFSet.h>

   105 #import <Foundation/NSURLConnection.h>

   106 #import <JavaScriptCore/APICast.h>

   107 #import <JavaScriptCore/JSValueRef.h>

   108 #import <WebCore/AbstractDatabase.h>

   109 #import <WebCore/ApplicationCacheStorage.h>

   110 #import <WebCore/BackForwardList.h>

   111 #import <WebCore/Cache.h>

   112 #import <WebCore/ColorMac.h>

   113 #import <WebCore/CSSComputedStyleDeclaration.h>

   114 #import <WebCore/Cursor.h>

   115 #import <WebCore/Document.h>

   116 #import <WebCore/DocumentLoader.h>

   117 #import <WebCore/DragController.h>

   118 #import <WebCore/DragData.h>

   119 #import <WebCore/Editor.h>

   120 #import <WebCore/EventHandler.h>

   121 #import <WebCore/ExceptionHandlers.h>

   122 #import <WebCore/FocusController.h>

   123 #import <WebCore/Frame.h>

   124 #import <WebCore/FrameLoader.h>

   125 #import <WebCore/FrameTree.h>

   126 #import <WebCore/FrameView.h>

   127 #import <WebCore/GCController.h>

   128 #import <WebCore/HTMLMediaElement.h>

   129 #import <WebCore/HTMLNames.h>

   130 #import <WebCore/HistoryItem.h>

   131 #import <WebCore/IconDatabase.h>

   132 #import <WebCore/JSCSSStyleDeclaration.h>

   133 #import <WebCore/JSElement.h>

   134 #import <WebCore/Logging.h>

   135 #import <WebCore/MIMETypeRegistry.h>

   136 #import <WebCore/Page.h>

   137 #import <WebCore/PageCache.h>

   138 #import <WebCore/PageGroup.h>

   139 #import <WebCore/PlatformMouseEvent.h>

   140 #import <WebCore/ProgressTracker.h>

   141 #import <WebCore/RenderWidget.h>

   142 #import <WebCore/ResourceHandle.h>

   143 #import <WebCore/RuntimeApplicationChecks.h>

   144 #import <WebCore/SchemeRegistry.h>

   145 #import <WebCore/ScriptController.h>

   146 #import <WebCore/ScriptValue.h>

   147 #import <WebCore/SecurityOrigin.h>

   148 #import <WebCore/SelectionController.h>

   149 #import <WebCore/Settings.h>

   150 #import <WebCore/TextResourceDecoder.h>

   151 #import <WebCore/ThreadCheck.h>

   152 #import <WebCore/WebCoreObjCExtras.h>

   153 #import <WebCore/WebCoreView.h>

   154 #import <WebCore/Widget.h>

   155 #import <WebKit/DOM.h>

   156 #import <WebKit/DOMExtensions.h>

   157 #import <WebKit/DOMPrivate.h>

   158 #import <WebKitSystemInterface.h>

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

   160 #import <objc/objc-auto.h>

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

   162 #import <runtime/ArrayPrototype.h>

   163 #import <runtime/DateInstance.h>

   164 #import <runtime/InitializeThreading.h>

   165 #import <runtime/JSLock.h>

   166 #import <runtime/JSValue.h>

   167 #import <wtf/Assertions.h>

   168 #import <wtf/HashTraits.h>

   169 #import <wtf/RefCountedLeakCounter.h>

   170 #import <wtf/RefPtr.h>

   171 #import <wtf/StdLibExtras.h>

   172 #import <wtf/Threading.h>

   173 

   174 #if ENABLE(DASHBOARD_SUPPORT)

   175 #import <WebKit/WebDashboardRegion.h>

   176 #endif

   177 

   178 #if ENABLE(CLIENT_BASED_GEOLOCATION)

   179 #import <WebCore/GeolocationController.h>

   180 #import <WebCore/GeolocationError.h>

   181 #endif

   182 

   183 #if ENABLE(VIDEO) && USE(GSTREAMER)

   184 #import <glib.h>

   185 #endif

   186 

   187 @interface NSSpellChecker (WebNSSpellCheckerDetails)

   188 - (void)_preflightChosenSpellServer;

   189 @end

   190 

   191 @interface NSView (WebNSViewDetails)

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

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

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

   195 @end

   196 

   197 @interface NSWindow (WebNSWindowDetails) 

   198 - (id)_oldFirstResponderBeforeBecoming;

   199 - (void)_enableScreenUpdatesIfNeeded;

   200 - (BOOL)_wrapsCarbonWindow;

   201 @end

   202 

   203 using namespace WebCore;

   204 using namespace JSC;

   205 

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

   207 #define PROCESSOR "PPC"

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

   209 #define PROCESSOR "Intel"

   210 #else

   211 #error Unknown architecture

   212 #endif

   213 

   214 #define FOR_EACH_RESPONDER_SELECTOR(macro) \

   215 macro(alignCenter) \

   216 macro(alignJustified) \

   217 macro(alignLeft) \

   218 macro(alignRight) \

   219 macro(capitalizeWord) \

   220 macro(centerSelectionInVisibleArea) \

   221 macro(changeAttributes) \

   222 macro(changeBaseWritingDirection) \

   223 macro(changeBaseWritingDirectionToLTR) \

   224 macro(changeBaseWritingDirectionToRTL) \

   225 macro(changeColor) \

   226 macro(changeDocumentBackgroundColor) \

   227 macro(changeFont) \

   228 macro(changeSpelling) \

   229 macro(checkSpelling) \

   230 macro(complete) \

   231 macro(copy) \

   232 macro(copyFont) \

   233 macro(cut) \

   234 macro(delete) \

   235 macro(deleteBackward) \

   236 macro(deleteBackwardByDecomposingPreviousCharacter) \

   237 macro(deleteForward) \

   238 macro(deleteToBeginningOfLine) \

   239 macro(deleteToBeginningOfParagraph) \

   240 macro(deleteToEndOfLine) \

   241 macro(deleteToEndOfParagraph) \

   242 macro(deleteToMark) \

   243 macro(deleteWordBackward) \

   244 macro(deleteWordForward) \

   245 macro(ignoreSpelling) \

   246 macro(indent) \

   247 macro(insertBacktab) \

   248 macro(insertLineBreak) \

   249 macro(insertNewline) \

   250 macro(insertNewlineIgnoringFieldEditor) \

   251 macro(insertParagraphSeparator) \

   252 macro(insertTab) \

   253 macro(insertTabIgnoringFieldEditor) \

   254 macro(lowercaseWord) \

   255 macro(makeBaseWritingDirectionLeftToRight) \

   256 macro(makeBaseWritingDirectionRightToLeft) \

   257 macro(makeTextWritingDirectionLeftToRight) \

   258 macro(makeTextWritingDirectionNatural) \

   259 macro(makeTextWritingDirectionRightToLeft) \

   260 macro(moveBackward) \

   261 macro(moveBackwardAndModifySelection) \

   262 macro(moveDown) \

   263 macro(moveDownAndModifySelection) \

   264 macro(moveForward) \

   265 macro(moveForwardAndModifySelection) \

   266 macro(moveLeft) \

   267 macro(moveLeftAndModifySelection) \

   268 macro(moveParagraphBackwardAndModifySelection) \

   269 macro(moveParagraphForwardAndModifySelection) \

   270 macro(moveRight) \

   271 macro(moveRightAndModifySelection) \

   272 macro(moveToBeginningOfDocument) \

   273 macro(moveToBeginningOfDocumentAndModifySelection) \

   274 macro(moveToBeginningOfLine) \

   275 macro(moveToBeginningOfLineAndModifySelection) \

   276 macro(moveToBeginningOfParagraph) \

   277 macro(moveToBeginningOfParagraphAndModifySelection) \

   278 macro(moveToBeginningOfSentence) \

   279 macro(moveToBeginningOfSentenceAndModifySelection) \

   280 macro(moveToEndOfDocument) \

   281 macro(moveToEndOfDocumentAndModifySelection) \

   282 macro(moveToEndOfLine) \

   283 macro(moveToEndOfLineAndModifySelection) \

   284 macro(moveToEndOfParagraph) \

   285 macro(moveToEndOfParagraphAndModifySelection) \

   286 macro(moveToEndOfSentence) \

   287 macro(moveToEndOfSentenceAndModifySelection) \

   288 macro(moveToLeftEndOfLine) \

   289 macro(moveToLeftEndOfLineAndModifySelection) \

   290 macro(moveToRightEndOfLine) \

   291 macro(moveToRightEndOfLineAndModifySelection) \

   292 macro(moveUp) \

   293 macro(moveUpAndModifySelection) \

   294 macro(moveWordBackward) \

   295 macro(moveWordBackwardAndModifySelection) \

   296 macro(moveWordForward) \

   297 macro(moveWordForwardAndModifySelection) \

   298 macro(moveWordLeft) \

   299 macro(moveWordLeftAndModifySelection) \

   300 macro(moveWordRight) \

   301 macro(moveWordRightAndModifySelection) \

   302 macro(outdent) \

   303 macro(orderFrontSubstitutionsPanel) \

   304 macro(pageDown) \

   305 macro(pageDownAndModifySelection) \

   306 macro(pageUp) \

   307 macro(pageUpAndModifySelection) \

   308 macro(paste) \

   309 macro(pasteAsPlainText) \

   310 macro(pasteAsRichText) \

   311 macro(pasteFont) \

   312 macro(performFindPanelAction) \

   313 macro(scrollLineDown) \

   314 macro(scrollLineUp) \

   315 macro(scrollPageDown) \

   316 macro(scrollPageUp) \

   317 macro(scrollToBeginningOfDocument) \

   318 macro(scrollToEndOfDocument) \

   319 macro(selectAll) \

   320 macro(selectLine) \

   321 macro(selectParagraph) \

   322 macro(selectSentence) \

   323 macro(selectToMark) \

   324 macro(selectWord) \

   325 macro(setMark) \

   326 macro(showGuessPanel) \

   327 macro(startSpeaking) \

   328 macro(stopSpeaking) \

   329 macro(subscript) \

   330 macro(superscript) \

   331 macro(swapWithMark) \

   332 macro(takeFindStringFromSelection) \

   333 macro(toggleBaseWritingDirection) \

   334 macro(transpose) \

   335 macro(underline) \

   336 macro(unscript) \

   337 macro(uppercaseWord) \

   338 macro(yank) \

   339 macro(yankAndSelect) \

   340 

   341 #define WebKitOriginalTopPrintingMarginKey @"WebKitOriginalTopMargin"

   342 #define WebKitOriginalBottomPrintingMarginKey @"WebKitOriginalBottomMargin"

   343 

   344 #define KeyboardUIModeDidChangeNotification @"com.apple.KeyboardUIModeDidChange"

   345 #define AppleKeyboardUIMode CFSTR("AppleKeyboardUIMode")

   346 #define UniversalAccessDomain CFSTR("com.apple.universalaccess")

   347 

   348 static BOOL s_didSetCacheModel;

   349 static WebCacheModel s_cacheModel = WebCacheModelDocumentViewer;

   350 

   351 #ifndef NDEBUG

   352 static const char webViewIsOpen[] = "At least one WebView is still open.";

   353 #endif

   354 

   355 @interface NSObject (WebValidateWithoutDelegate)

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

   357 @end

   358 

   359 @interface _WebSafeForwarder : NSObject

   360 {

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

   362     id defaultTarget;

   363     BOOL catchExceptions;

   364 }

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

   366 @end

   367 

   368 @interface WebView (WebFileInternal)

   369 - (BOOL)_isLoading;

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

   371 - (WebFrame *)_focusedFrame;

   372 + (void)_preflightSpellChecker;

   373 - (BOOL)_continuousCheckingAllowed;

   374 - (NSResponder *)_responderForResponderOperations;

   375 #if USE(ACCELERATED_COMPOSITING)

   376 - (void)_clearLayerSyncLoopObserver;

   377 #endif

   378 #if ENABLE(VIDEO) && USE(GSTREAMER)

   379 - (void)_clearGlibLoopObserver;

   380 #endif

   381 @end

   382 

   383 static void patchMailRemoveAttributesMethod();

   384 

   385 NSString *WebElementDOMNodeKey =            @"WebElementDOMNode";

   386 NSString *WebElementFrameKey =              @"WebElementFrame";

   387 NSString *WebElementImageKey =              @"WebElementImage";

   388 NSString *WebElementImageAltStringKey =     @"WebElementImageAltString";

   389 NSString *WebElementImageRectKey =          @"WebElementImageRect";

   390 NSString *WebElementImageURLKey =           @"WebElementImageURL";

   391 NSString *WebElementIsSelectedKey =         @"WebElementIsSelected";

   392 NSString *WebElementLinkLabelKey =          @"WebElementLinkLabel";

   393 NSString *WebElementLinkTargetFrameKey =    @"WebElementTargetFrame";

   394 NSString *WebElementLinkTitleKey =          @"WebElementLinkTitle";

   395 NSString *WebElementLinkURLKey =            @"WebElementLinkURL";

   396 NSString *WebElementSpellingToolTipKey =    @"WebElementSpellingToolTip";

   397 NSString *WebElementTitleKey =              @"WebElementTitle";

   398 NSString *WebElementLinkIsLiveKey =         @"WebElementLinkIsLive";

   399 NSString *WebElementIsInScrollBarKey =      @"WebElementIsInScrollBar";

   400 NSString *WebElementIsContentEditableKey =  @"WebElementIsContentEditableKey";

   401 

   402 NSString *WebViewProgressStartedNotification =          @"WebProgressStartedNotification";

   403 NSString *WebViewProgressEstimateChangedNotification =  @"WebProgressEstimateChangedNotification";

   404 NSString *WebViewProgressFinishedNotification =         @"WebProgressFinishedNotification";

   405 

   406 NSString * const WebViewDidBeginEditingNotification =         @"WebViewDidBeginEditingNotification";

   407 NSString * const WebViewDidChangeNotification =               @"WebViewDidChangeNotification";

   408 NSString * const WebViewDidEndEditingNotification =           @"WebViewDidEndEditingNotification";

   409 NSString * const WebViewDidChangeTypingStyleNotification =    @"WebViewDidChangeTypingStyleNotification";

   410 NSString * const WebViewDidChangeSelectionNotification =      @"WebViewDidChangeSelectionNotification";

   411 

   412 enum { WebViewVersion = 4 };

   413 

   414 #define timedLayoutSize 4096

   415 

   416 static NSMutableSet *schemesWithRepresentationsSet;

   417 

   418 NSString *_WebCanGoBackKey =            @"canGoBack";

   419 NSString *_WebCanGoForwardKey =         @"canGoForward";

   420 NSString *_WebEstimatedProgressKey =    @"estimatedProgress";

   421 NSString *_WebIsLoadingKey =            @"isLoading";

   422 NSString *_WebMainFrameIconKey =        @"mainFrameIcon";

   423 NSString *_WebMainFrameTitleKey =       @"mainFrameTitle";

   424 NSString *_WebMainFrameURLKey =         @"mainFrameURL";

   425 NSString *_WebMainFrameDocumentKey =    @"mainFrameDocument";

   426 

   427 NSString *_WebViewDidStartAcceleratedCompositingNotification = @"_WebViewDidStartAcceleratedCompositing";

   428 

   429 @interface WebProgressItem : NSObject

   430 {

   431 @public

   432     long long bytesReceived;

   433     long long estimatedLength;

   434 }

   435 @end

   436 

   437 @implementation WebProgressItem

   438 @end

   439 

   440 static BOOL continuousSpellCheckingEnabled;

   441 #ifndef BUILDING_ON_TIGER

   442 static BOOL grammarCheckingEnabled;

   443 #endif

   444 #if !defined(BUILDING_ON_TIGER) && !defined(BUILDING_ON_LEOPARD)

   445 static BOOL automaticQuoteSubstitutionEnabled;

   446 static BOOL automaticLinkDetectionEnabled;

   447 static BOOL automaticDashSubstitutionEnabled;

   448 static BOOL automaticTextReplacementEnabled;

   449 static BOOL automaticSpellingCorrectionEnabled;

   450 #endif

   451 

   452 @implementation WebView (AllWebViews)

   453 

   454 static CFSetCallBacks NonRetainingSetCallbacks = {

   455     0,

   456     NULL,

   457     NULL,

   458     CFCopyDescription,

   459     CFEqual,

   460     CFHash

   461 };

   462 

   463 static CFMutableSetRef allWebViewsSet;

   464 

   465 + (void)_makeAllWebViewsPerformSelector:(SEL)selector

   466 {

   467     if (!allWebViewsSet)

   468         return;

   469 

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

   471 }

   472 

   473 - (void)_removeFromAllWebViewsSet

   474 {

   475     if (allWebViewsSet)

   476         CFSetRemoveValue(allWebViewsSet, self);

   477 }

   478 

   479 - (void)_addToAllWebViewsSet

   480 {

   481     if (!allWebViewsSet)

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

   483 

   484     CFSetSetValue(allWebViewsSet, self);

   485 }

   486 

   487 @end

   488 

   489 @implementation WebView (WebPrivate)

   490 

   491 static inline int callGestalt(OSType selector)

   492 {

   493     SInt32 value = 0;

   494     Gestalt(selector, &value);

   495     return value;

   496 }

   497 

   498 // Uses underscores instead of dots because if "4." ever appears in a user agent string, old DHTML libraries treat it as Netscape 4.

   499 static NSString *createMacOSXVersionString()

   500 {

   501     // Can't use -[NSProcessInfo operatingSystemVersionString] because it has too much stuff we don't want.

   502     int major = callGestalt(gestaltSystemVersionMajor);

   503     ASSERT(major);

   504 

   505     int minor = callGestalt(gestaltSystemVersionMinor);

   506     int bugFix = callGestalt(gestaltSystemVersionBugFix);

   507     if (bugFix)

   508         return [[NSString alloc] initWithFormat:@"%d_%d_%d", major, minor, bugFix];

   509     if (minor)

   510         return [[NSString alloc] initWithFormat:@"%d_%d", major, minor];

   511     return [[NSString alloc] initWithFormat:@"%d", major];

   512 }

   513 

   514 static NSString *createUserVisibleWebKitVersionString()

   515 {

   516     // If the version is 4 digits long or longer, then the first digit represents

   517     // the version of the OS. Our user agent string should not include this first digit,

   518     // so strip it off and report the rest as the version. <rdar://problem/4997547>

   519     NSString *fullVersion = [[NSBundle bundleForClass:[WebView class]] objectForInfoDictionaryKey:(NSString *)kCFBundleVersionKey];

   520     NSRange nonDigitRange = [fullVersion rangeOfCharacterFromSet:[[NSCharacterSet decimalDigitCharacterSet] invertedSet]];

   521     if (nonDigitRange.location == NSNotFound && [fullVersion length] >= 4)

   522         return [[fullVersion substringFromIndex:1] copy];

   523     if (nonDigitRange.location != NSNotFound && nonDigitRange.location >= 4)

   524         return [[fullVersion substringFromIndex:1] copy];

   525     return [fullVersion copy];

   526 }

   527 

   528 + (NSString *)_standardUserAgentWithApplicationName:(NSString *)applicationName

   529 {

   530     // Note: Do *not* move the initialization of osVersion nor webKitVersion into the declaration.

   531     // Garbage collection won't correctly mark the global variable in that case <rdar://problem/5733674>.

   532     static NSString *osVersion;

   533     static NSString *webKitVersion;

   534     if (!osVersion)

   535         osVersion = createMacOSXVersionString();

   536     if (!webKitVersion)

   537         webKitVersion = createUserVisibleWebKitVersionString();

   538     NSString *language = [NSUserDefaults _webkit_preferredLanguageCode];

   539     if ([applicationName length])

   540         return [NSString stringWithFormat:@"Mozilla/5.0 (Macintosh; U; " PROCESSOR " Mac OS X %@; %@) AppleWebKit/%@ (KHTML, like Gecko) %@", osVersion, language, webKitVersion, applicationName];

   541     return [NSString stringWithFormat:@"Mozilla/5.0 (Macintosh; U; " PROCESSOR " Mac OS X %@; %@) AppleWebKit/%@ (KHTML, like Gecko)", osVersion, language, webKitVersion];

   542 }

   543 

   544 + (void)_reportException:(JSValueRef)exception inContext:(JSContextRef)context

   545 {

   546     if (!exception || !context)

   547         return;

   548 

   549     JSLock lock(SilenceAssertionsOnly);

   550     JSC::ExecState* execState = toJS(context);

   551 

   552     // Make sure the context has a DOMWindow global object, otherwise this context didn't originate from a WebView.

   553     if (!toJSDOMWindow(execState->lexicalGlobalObject()))

   554         return;

   555 

   556     reportException(execState, toJS(execState, exception));

   557 }

   558 

   559 static void WebKitInitializeApplicationCachePathIfNecessary()

   560 {

   561 #if ENABLE(OFFLINE_WEB_APPLICATIONS)

   562     static BOOL initialized = NO;

   563     if (initialized)

   564         return;

   565 

   566     NSString *appName = [[NSBundle mainBundle] bundleIdentifier];

   567     if (!appName)

   568         appName = [[NSProcessInfo processInfo] processName];

   569     

   570     ASSERT(appName);

   571 

   572     NSString* cacheDir = [NSString _webkit_localCacheDirectoryWithBundleIdentifier:appName];

   573 

   574     cacheStorage().setCacheDirectory(cacheDir);

   575     initialized = YES;

   576 #endif

   577 }

   578 

   579 static bool runningLeopardMail()

   580 {

   581 #ifdef BUILDING_ON_LEOPARD

   582     return applicationIsAppleMail();

   583 #endif

   584     return NO;

   585 }

   586 

   587 static bool runningTigerMail()

   588 {

   589 #ifdef BUILDING_ON_TIGER

   590     return applicationIsAppleMail();

   591 #endif

   592     return NO;    

   593 }

   594 

   595 static bool coreVideoHas7228836Fix()

   596 {

   597 #ifdef BUILDING_ON_LEOPARD

   598     NSBundle* coreVideoFrameworkBundle = [NSBundle bundleWithPath:@"/System/Library/Frameworks/CoreVideo.framework"];

   599     double version = [[coreVideoFrameworkBundle objectForInfoDictionaryKey:(NSString *)kCFBundleVersionKey] doubleValue];

   600     return (version >= 48);

   601 #endif

   602     return true;

   603 }

   604 

   605 static bool shouldEnableLoadDeferring()

   606 {

   607     return !applicationIsAdobeInstaller();

   608 }

   609 

   610 - (void)_dispatchPendingLoadRequests

   611 {

   612     cache()->loader()->servePendingRequests();

   613 }

   614 

   615 - (void)_registerDraggedTypes

   616 {

   617     NSArray *editableTypes = [WebHTMLView _insertablePasteboardTypes];

   618     NSArray *URLTypes = [NSPasteboard _web_dragTypesForURL];

   619     NSMutableSet *types = [[NSMutableSet alloc] initWithArray:editableTypes];

   620     [types addObjectsFromArray:URLTypes];

   621     [self registerForDraggedTypes:[types allObjects]];

   622     [types release];

   623 }

   624 

   625 - (BOOL)_usesDocumentViews

   626 {

   627     return _private->usesDocumentViews;

   628 }

   629 

   630 - (void)_commonInitializationWithFrameName:(NSString *)frameName groupName:(NSString *)groupName usesDocumentViews:(BOOL)usesDocumentViews

   631 {

   632     WebCoreThreadViolationCheckRoundTwo();

   633 

   634 #ifndef NDEBUG

   635     WTF::RefCountedLeakCounter::suppressMessages(webViewIsOpen);

   636 #endif

   637     

   638     WebPreferences *standardPreferences = [WebPreferences standardPreferences];

   639     [standardPreferences willAddToWebView];

   640 

   641     _private->preferences = [standardPreferences retain];

   642     _private->catchesDelegateExceptions = YES;

   643     _private->mainFrameDocumentReady = NO;

   644     _private->drawsBackground = YES;

   645     _private->backgroundColor = [[NSColor colorWithDeviceWhite:1 alpha:1] retain];

   646     _private->usesDocumentViews = usesDocumentViews;

   647     _private->includesFlattenedCompositingLayersWhenDrawingToBitmap = YES;

   648 

   649     WebFrameView *frameView = nil;

   650     if (_private->usesDocumentViews) {

   651         NSRect f = [self frame];

   652         frameView = [[WebFrameView alloc] initWithFrame: NSMakeRect(0,0,f.size.width,f.size.height)];

   653         [frameView setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];

   654         [self addSubview:frameView];

   655         [frameView release];

   656     }

   657 

   658     static bool didOneTimeInitialization = false;

   659     if (!didOneTimeInitialization) {

   660         WebKitInitializeLoggingChannelsIfNecessary();

   661         WebCore::InitializeLoggingChannelsIfNecessary();

   662         [WebHistoryItem initWindowWatcherIfNecessary];

   663 #if ENABLE(DATABASE)

   664         WebKitInitializeDatabasesIfNecessary();

   665 #endif

   666         WebKitInitializeApplicationCachePathIfNecessary();

   667         patchMailRemoveAttributesMethod();

   668         

   669         // Initialize our platform strategies.

   670         WebPlatformStrategies::initialize();

   671 

   672         didOneTimeInitialization = true;

   673     }

   674 

   675 #if ENABLE(CLIENT_BASED_GEOLOCATION)

   676     WebGeolocationControllerClient* geolocationControllerClient = new WebGeolocationControllerClient(self);

   677 #else

   678     WebGeolocationControllerClient* geolocationControllerClient = 0;

   679 #endif

   680     _private->page = new Page(new WebChromeClient(self), new WebContextMenuClient(self), new WebEditorClient(self), new WebDragClient(self), new WebInspectorClient(self), new WebPluginHalterClient(self), geolocationControllerClient, 0, 0);

   681 

   682     _private->page->setCanStartMedia([self window]);

   683     _private->page->settings()->setLocalStorageDatabasePath([[self preferences] _localStorageDatabasePath]);

   684 

   685     [WebFrame _createMainFrameWithPage:_private->page frameName:frameName frameView:frameView];

   686 

   687 #ifndef BUILDING_ON_TIGER

   688     NSRunLoop *runLoop = [NSRunLoop mainRunLoop];

   689 #else

   690     NSRunLoop *runLoop = [NSRunLoop currentRunLoop];

   691 #endif

   692 

   693     if (WebKitLinkedOnOrAfter(WEBKIT_FIRST_VERSION_WITH_LOADING_DURING_COMMON_RUNLOOP_MODES))

   694         [self scheduleInRunLoop:runLoop forMode:(NSString *)kCFRunLoopCommonModes];

   695     else

   696         [self scheduleInRunLoop:runLoop forMode:NSDefaultRunLoopMode];

   697 

   698     [self _addToAllWebViewsSet];

   699     [self setGroupName:groupName];

   700     

   701     // If there's already a next key view (e.g., from a nib), wire it up to our

   702     // contained frame view. In any case, wire our next key view up to the our

   703     // contained frame view. This works together with our becomeFirstResponder 

   704     // and setNextKeyView overrides.

   705     NSView *nextKeyView = [self nextKeyView];

   706     if (nextKeyView && nextKeyView != frameView)

   707         [frameView setNextKeyView:nextKeyView];

   708     [super setNextKeyView:frameView];

   709 

   710     if ([[self class] shouldIncludeInWebKitStatistics])

   711         ++WebViewCount;

   712 

   713     [self _registerDraggedTypes];

   714 

   715     WebPreferences *prefs = [self preferences];

   716     [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(_preferencesChangedNotification:)

   717                                                  name:WebPreferencesChangedNotification object:prefs];

   718 

   719     // Post a notification so the WebCore settings update.

   720     [[self preferences] _postPreferencesChangesNotification];

   721 

   722     if (!WebKitLinkedOnOrAfter(WEBKIT_FIRST_VERSION_WITH_LOCAL_RESOURCE_SECURITY_RESTRICTION)) {

   723         // Originally, we allowed all local loads.

   724         SecurityOrigin::setLocalLoadPolicy(SecurityOrigin::AllowLocalLoadsForAll);

   725     } else if (!WebKitLinkedOnOrAfter(WEBKIT_FIRST_VERSION_WITH_MORE_STRICT_LOCAL_RESOURCE_SECURITY_RESTRICTION)) {

   726         // Later, we allowed local loads for local URLs and documents loaded

   727         // with substitute data.

   728         SecurityOrigin::setLocalLoadPolicy(SecurityOrigin::AllowLocalLoadsForLocalAndSubstituteData);

   729     }

   730 

   731     if (!WebKitLinkedOnOrAfter(WEBKIT_FIRST_VERSION_WITHOUT_CONTENT_SNIFFING_FOR_FILE_URLS))

   732         ResourceHandle::forceContentSniffing();

   733 

   734 #if ENABLE(VIDEO) && USE(GSTREAMER)

   735     [self _scheduleGlibContextIterations];

   736 #endif

   737 

   738 }

   739 

   740 - (id)_initWithFrame:(NSRect)f frameName:(NSString *)frameName groupName:(NSString *)groupName usesDocumentViews:(BOOL)usesDocumentViews

   741 {

   742     self = [super initWithFrame:f];

   743     if (!self)

   744         return nil;

   745 

   746 #ifdef ENABLE_WEBKIT_UNSET_DYLD_FRAMEWORK_PATH

   747     // DYLD_FRAMEWORK_PATH is used so Safari will load the development version of WebKit, which

   748     // may not work with other WebKit applications.  Unsetting DYLD_FRAMEWORK_PATH removes the

   749     // need for Safari to unset it to prevent it from being passed to applications it launches.

   750     // Unsetting it when a WebView is first created is as good a place as any.

   751     // See <http://bugs.webkit.org/show_bug.cgi?id=4286> for more details.

   752     if (getenv("WEBKIT_UNSET_DYLD_FRAMEWORK_PATH")) {

   753         unsetenv("DYLD_FRAMEWORK_PATH");

   754         unsetenv("WEBKIT_UNSET_DYLD_FRAMEWORK_PATH");

   755     }

   756 #endif

   757 

   758     _private = [[WebViewPrivate alloc] init];

   759     [self _commonInitializationWithFrameName:frameName groupName:groupName usesDocumentViews:usesDocumentViews];

   760     [self setMaintainsBackForwardList: YES];

   761     return self;

   762 }

   763 

   764 - (BOOL)_mustDrawUnionedRect:(NSRect)rect singleRects:(const NSRect *)rects count:(NSInteger)count

   765 {

   766     // If count == 0 here, use the rect passed in for drawing. This is a workaround for:

   767     // <rdar://problem/3908282> REGRESSION (Mail): No drag image dragging selected text in Blot and Mail

   768     // The reason for the workaround is that this method is called explicitly from the code

   769     // to generate a drag image, and at that time, getRectsBeingDrawn:count: will return a zero count.

   770     const int cRectThreshold = 10;

   771     const float cWastedSpaceThreshold = 0.75f;

   772     BOOL useUnionedRect = (count <= 1) || (count > cRectThreshold);

   773     if (!useUnionedRect) {

   774         // Attempt to guess whether or not we should use the unioned rect or the individual rects.

   775         // We do this by computing the percentage of "wasted space" in the union.  If that wasted space

   776         // is too large, then we will do individual rect painting instead.

   777         float unionPixels = (rect.size.width * rect.size.height);

   778         float singlePixels = 0;

   779         for (int i = 0; i < count; ++i)

   780             singlePixels += rects[i].size.width * rects[i].size.height;

   781         float wastedSpace = 1 - (singlePixels / unionPixels);

   782         if (wastedSpace <= cWastedSpaceThreshold)

   783             useUnionedRect = YES;

   784     }

   785     return useUnionedRect;

   786 }

   787 

   788 - (void)drawSingleRect:(NSRect)rect

   789 {

   790     ASSERT(!_private->usesDocumentViews);

   791     

   792     [NSGraphicsContext saveGraphicsState];

   793     NSRectClip(rect);

   794 

   795     @try {

   796         [[self mainFrame] _drawRect:rect contentsOnly:NO];

   797 

   798         [[self _UIDelegateForwarder] webView:self didDrawRect:rect];

   799 

   800         if (WebNodeHighlight *currentHighlight = [self currentNodeHighlight])

   801             [currentHighlight setNeedsUpdateInTargetViewRect:rect];

   802 

   803         [NSGraphicsContext restoreGraphicsState];

   804     } @catch (NSException *localException) {

   805         [NSGraphicsContext restoreGraphicsState];

   806         LOG_ERROR("Exception caught while drawing: %@", localException);

   807         [localException raise];

   808     }

   809 }

   810 

   811 - (BOOL)isFlipped 

   812 {

   813     return _private && !_private->usesDocumentViews;

   814 }

   815 

   816 - (void)setFrameSize:(NSSize)size

   817 {

   818     if (!_private->usesDocumentViews && !NSEqualSizes(_private->lastLayoutSize, size)) {

   819         Frame* frame = [self _mainCoreFrame];

   820         // FIXME: Viewless WebKit is broken with Safari banners (e.g., the Find banner).  We'll have to figure out a way for

   821         // Safari to communicate that this space is being consumed.  For WebKit with document views, there's no

   822         // need to do an explicit resize, since WebFrameViews have auto resizing turned on and will handle changing

   823         // their bounds automatically. See <rdar://problem/6835573> for details.

   824         frame->view()->resize(IntSize(size));

   825         frame->view()->setNeedsLayout();

   826         [self setNeedsDisplay:YES];

   827         _private->lastLayoutSize = size;

   828     }

   829 

   830     [super setFrameSize:size];

   831 }

   832 

   833 #if USE(ACCELERATED_COMPOSITING) || !defined(BUILDING_ON_TIGER)

   834 

   835 - (void)_viewWillDrawInternal

   836 {

   837     Frame* frame = [self _mainCoreFrame];

   838     if (frame && frame->view())

   839         frame->view()->layoutIfNeededRecursive();

   840 }

   841 

   842 #endif

   843 

   844 #ifndef BUILDING_ON_TIGER

   845 

   846 - (void)viewWillDraw

   847 {

   848     if (!_private->usesDocumentViews)

   849         [self _viewWillDrawInternal];

   850     [super viewWillDraw];

   851 }

   852 

   853 #endif

   854 

   855 

   856 - (void)drawRect:(NSRect)rect

   857 {

   858     if (_private->usesDocumentViews)

   859         return [super drawRect:rect];

   860     

   861     ASSERT_MAIN_THREAD();

   862 

   863     const NSRect *rects;

   864     NSInteger count;

   865     [self getRectsBeingDrawn:&rects count:&count];

   866 

   867     

   868     if ([self _mustDrawUnionedRect:rect singleRects:rects count:count])

   869         [self drawSingleRect:rect];

   870     else

   871         for (int i = 0; i < count; ++i)

   872             [self drawSingleRect:rects[i]];

   873 }

   874 

   875 + (NSArray *)_supportedMIMETypes

   876 {

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

   878     [WebPluginDatabase sharedDatabase];

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

   880 }

   881 

   882 + (NSArray *)_supportedFileExtensions

   883 {

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

   885     NSArray *MIMETypes = [self _supportedMIMETypes];

   886     NSEnumerator *enumerator = [MIMETypes objectEnumerator];

   887     NSString *MIMEType;

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

   889         NSArray *extensionsForType = WKGetExtensionsForMIMEType(MIMEType);

   890         if (extensionsForType) {

   891             [extensions addObjectsFromArray:extensionsForType];

   892         }

   893     }

   894     NSArray *uniqueExtensions = [extensions allObjects];

   895     [extensions release];

   896     return uniqueExtensions;

   897 }

   898 

   899 static NSMutableSet *knownPluginMIMETypes()

   900 {

   901     static NSMutableSet *mimeTypes = [[NSMutableSet alloc] init];

   902     

   903     return mimeTypes;

   904 }

   905 

   906 + (void)_registerPluginMIMEType:(NSString *)MIMEType

   907 {

   908     [WebView registerViewClass:[WebHTMLView class] representationClass:[WebHTMLRepresentation class] forMIMEType:MIMEType];

   909     [knownPluginMIMETypes() addObject:MIMEType];

   910 }

   911 

   912 + (void)_unregisterPluginMIMEType:(NSString *)MIMEType

   913 {

   914     [self _unregisterViewClassAndRepresentationClassForMIMEType:MIMEType];

   915     [knownPluginMIMETypes() removeObject:MIMEType];

   916 }

   917 

   918 + (BOOL)_viewClass:(Class *)vClass andRepresentationClass:(Class *)rClass forMIMEType:(NSString *)MIMEType allowingPlugins:(BOOL)allowPlugins

   919 {

   920     MIMEType = [MIMEType lowercaseString];

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

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

   923 

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

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

   926 

   927         if (allowPlugins) {

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

   929             [WebPluginDatabase sharedDatabase];

   930         }

   931 

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

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

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

   935     }

   936     

   937     if (viewClass && repClass) {

   938         if (viewClass == [WebHTMLView class] && repClass == [WebHTMLRepresentation class]) {

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

   940             if ([[WebHTMLView unsupportedTextMIMETypes] containsObject:MIMEType])

   941                 return NO;

   942 

   943             // If the MIME type is a known plug-in we might not want to load it.

   944             if (!allowPlugins && [knownPluginMIMETypes() containsObject:MIMEType]) {

   945                 BOOL isSupportedByWebKit = [[WebHTMLView supportedNonImageMIMETypes] containsObject:MIMEType] ||

   946                     [[WebHTMLView supportedMIMETypes] containsObject:MIMEType];

   947                 

   948                 // If this is a known plug-in MIME type and WebKit can't show it natively, we don't want to show it.

   949                 if (!isSupportedByWebKit)

   950                     return NO;

   951             }

   952         }

   953         if (vClass)

   954             *vClass = viewClass;

   955         if (rClass)

   956             *rClass = repClass;

   957         return YES;

   958     }

   959     

   960     return NO;

   961 }

   962 

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

   964 {

   965     if ([[self class] _viewClass:vClass andRepresentationClass:rClass forMIMEType:MIMEType allowingPlugins:[_private->preferences arePlugInsEnabled]])

   966         return YES;

   967 

   968     if (_private->pluginDatabase) {

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

   970         if (pluginPackage) {

   971             if (vClass)

   972                 *vClass = [WebHTMLView class];

   973             if (rClass)

   974                 *rClass = [WebHTMLRepresentation class];

   975             return YES;

   976         }

   977     }

   978     

   979     return NO;

   980 }

   981 

   982 + (void)_setAlwaysUseATSU:(BOOL)f

   983 {

   984     [self _setAlwaysUsesComplexTextCodePath:f];

   985 }

   986 

   987 + (void)_setAlwaysUsesComplexTextCodePath:(BOOL)f

   988 {

   989     Font::setCodePath(f ? Font::Complex : Font::Auto);

   990 }

   991 

   992 + (BOOL)canCloseAllWebViews

   993 {

   994     return DOMWindow::dispatchAllPendingBeforeUnloadEvents();

   995 }

   996 

   997 + (void)closeAllWebViews

   998 {

   999     DOMWindow::dispatchAllPendingUnloadEvents();

  1000 

  1001     // This will close the WebViews in a random order. Change this if close order is important.

  1002     // Make a new set to avoid mutating the set we are enumerating.

  1003     NSSet *webViewsToClose = [NSSet setWithSet:(NSSet *)allWebViewsSet]; 

  1004     NSEnumerator *enumerator = [webViewsToClose objectEnumerator];

  1005     while (WebView *webView = [enumerator nextObject])

  1006         [webView close];

  1007 }

  1008 

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

  1010 {

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

  1012 }

  1013 

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

  1015 {

  1016     return WKGetPreferredExtensionForMIMEType(type);

  1017 }

  1018 

  1019 - (BOOL)_isClosed

  1020 {

  1021     return !_private || _private->closed;

  1022 }

  1023 

  1024 - (void)_closePluginDatabases

  1025 {

  1026     pluginDatabaseClientCount--;

  1027 

  1028     // Close both sets of plug-in databases because plug-ins need an opportunity to clean up files, etc.

  1029 

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

  1031     if (_private->pluginDatabase) {

  1032         [_private->pluginDatabase destroyAllPluginInstanceViews];

  1033         [_private->pluginDatabase close];

  1034         [_private->pluginDatabase release];

  1035         _private->pluginDatabase = nil;

  1036     }

  1037     

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

  1039     if (!pluginDatabaseClientCount && applicationIsTerminating)

  1040         [WebPluginDatabase closeSharedDatabase];

  1041 }

  1042 

  1043 - (void)_closeWithFastTeardown 

  1044 {

  1045 #ifndef NDEBUG

  1046     WTF::RefCountedLeakCounter::suppressMessages("At least one WebView was closed with fast teardown.");

  1047 #endif

  1048 

  1049     [[NSDistributedNotificationCenter defaultCenter] removeObserver:self];

  1050     [[NSNotificationCenter defaultCenter] removeObserver:self];

  1051 

  1052     [self _closePluginDatabases];

  1053 }

  1054 

  1055 static bool fastDocumentTeardownEnabled()

  1056 {

  1057 #ifdef NDEBUG

  1058     static bool enabled = ![[NSUserDefaults standardUserDefaults] boolForKey:WebKitEnableFullDocumentTeardownPreferenceKey];

  1059 #else

  1060     static bool initialized = false;

  1061     static bool enabled = false;

  1062     if (!initialized) {

  1063         // This allows debug builds to default to not have fast teardown, so leak checking still works.

  1064         // But still allow the WebKitEnableFullDocumentTeardown default to override it if present.

  1065         NSNumber *setting = [[NSUserDefaults standardUserDefaults] objectForKey:WebKitEnableFullDocumentTeardownPreferenceKey];

  1066         if (setting)

  1067             enabled = ![setting boolValue];

  1068         initialized = true;

  1069     }

  1070 #endif

  1071     return enabled;

  1072 }

  1073 

  1074 // _close is here only for backward compatibility; clients and subclasses should use

  1075 // public method -close instead.

  1076 - (void)_close

  1077 {

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

  1079         return;

  1080 

  1081     _private->closed = YES;

  1082     [self _removeFromAllWebViewsSet];

  1083 

  1084     [self _closingEventHandling];

  1085 

  1086 #ifndef NDEBUG

  1087     WTF::RefCountedLeakCounter::cancelMessageSuppression(webViewIsOpen);

  1088 #endif

  1089 

  1090     // To quit the apps fast we skip document teardown, except plugins

  1091     // need to be destroyed and unloaded.

  1092     if (applicationIsTerminating && fastDocumentTeardownEnabled()) {

  1093         [self _closeWithFastTeardown];

  1094         return;

  1095     }

  1096 

  1097 #if ENABLE(VIDEO)

  1098     [self _exitFullscreen];

  1099 #endif

  1100 

  1101     if (Frame* mainFrame = [self _mainCoreFrame])

  1102         mainFrame->loader()->detachFromParent();

  1103 

  1104     [self setHostWindow:nil];

  1105 

  1106     [self setDownloadDelegate:nil];

  1107     [self setEditingDelegate:nil];

  1108     [self setFrameLoadDelegate:nil];

  1109     [self setPolicyDelegate:nil];

  1110     [self setResourceLoadDelegate:nil];

  1111     [self setScriptDebugDelegate:nil];

  1112     [self setUIDelegate:nil];

  1113 

  1114     [_private->inspector webViewClosed];

  1115 

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

  1117     [self removeDragCaret];

  1118 

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

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

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

  1122     Page* page = _private->page;

  1123     _private->page = 0;

  1124     delete page;

  1125 

  1126     if (_private->hasSpellCheckerDocumentTag) {

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

  1128         _private->hasSpellCheckerDocumentTag = NO;

  1129     }

  1130 

  1131 #if USE(ACCELERATED_COMPOSITING)

  1132     [self _clearLayerSyncLoopObserver];

  1133 #endif

  1134     

  1135 #if ENABLE(VIDEO) && USE(GSTREAMER)