Reviewed by Adele.
authormjs <mjs@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 2 Aug 2006 08:11:39 +0000 (08:11 +0000)
committermjs <mjs@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 2 Aug 2006 08:11:39 +0000 (08:11 +0000)
        - Change things around so WebFrameLoader tracks the main and provisional data source,
        as well as the frame load state, pulling much code out of WebFrame along the way.

        The most significant aspects of this change are:

        - management of WebDataSources and WebFrameState was moved into WebFrameLoader
        - there is now just one WebFrameLoader shared between the primary and provisional data source

        * WebKit.xcodeproj/project.pbxproj:
        * WebView/WebDataSource.m:
        (-[WebDataSourcePrivate dealloc]):
        (-[WebDataSource _updateLoading]):
        (-[WebDataSource _loadIcon]):
        (-[WebDataSource _setPrimaryLoadComplete:]):
        (-[WebDataSource _stopLoading]):
        (-[WebDataSource _startLoading]):
        (-[WebDataSource _addSubresourceLoader:]):
        (-[WebDataSource _removeSubresourceLoader:]):
        (-[WebDataSource _addPlugInStreamLoader:]):
        (-[WebDataSource _removePlugInStreamLoader:]):
        (-[WebDataSource _defersCallbacksChanged]):
        (-[WebDataSource _stopLoadingWithError:]):
        (-[WebDataSource _revertToProvisionalState]):
        (-[WebDataSource _setupForReplaceByMIMEType:]):
        (-[WebDataSource initWithRequest:]):
        (-[WebDataSource data]):
        (-[WebDataSource isLoading]):
        * WebView/WebFrame.m:
        (-[WebFramePrivate init]):
        (-[WebFramePrivate dealloc]):
        (-[WebFrame _closeOldDataSources]):
        (-[WebFrame _detachFromParent]):
        (-[WebFrame _makeDocumentView]):
        (-[WebFrame _receivedMainResourceError:]):
        (-[WebFrame _transitionToCommitted:]):
        (+[WebFrame _timeOfLastCompletedLoad]):
        (-[WebFrame _checkLoadCompleteForThisFrame]):
        (-[WebFrame _loadItem:withLoadType:]):
        (-[WebFrame _continueAfterWillSubmitForm:]):
        (-[WebFrame _continueLoadRequestAfterNavigationPolicy:formState:]):
        (-[WebFrame _initWithWebFrameView:webView:bridge:]):
        (-[WebFrame _frameLoader]):
        (-[WebFrame _provisionalLoadStarted]):
        (-[WebFrame _prepareForDataSourceReplacement]):
        (-[WebFrame _frameLoadCompleted]):
        (-[WebFrame provisionalDataSource]):
        (-[WebFrame dataSource]):
        (-[WebFrame stopLoading]):
        * WebView/WebFrameInternal.h:
        * WebView/WebFrameLoader.h:
        * WebView/WebFrameLoader.m:
        (-[WebFrameLoader initWithWebFrame:]):
        (-[WebFrameLoader dealloc]):
        (-[WebFrameLoader dataSource]):
        (-[WebFrameLoader _setDataSource:]):
        (-[WebFrameLoader clearDataSource]):
        (-[WebFrameLoader provisionalDataSource]):
        (-[WebFrameLoader _setProvisionalDataSource:]):
        (-[WebFrameLoader _clearProvisionalDataSource]):
        (-[WebFrameLoader state]):
        (+[WebFrameLoader timeOfLastCompletedLoad]):
        (-[WebFrameLoader _setState:]):
        (-[WebFrameLoader clearProvisionalLoad]):
        (-[WebFrameLoader markLoadComplete]):
        (-[WebFrameLoader commitProvisionalLoad]):
        (-[WebFrameLoader stopLoading]):
        (-[WebFrameLoader startLoading]):
        (-[WebFrameLoader startProvisionalLoad:]):
        (-[WebFrameLoader setupForReplace]):
        * WebView/WebFramePrivate.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@15751 268f45cc-cd09-0410-ab3c-d52691b4dbfc

WebKit/ChangeLog
WebKit/WebKit.xcodeproj/project.pbxproj
WebKit/WebView/WebDataSource.m
WebKit/WebView/WebFrame.m
WebKit/WebView/WebFrameInternal.h
WebKit/WebView/WebFrameLoader.h
WebKit/WebView/WebFrameLoader.m
WebKit/WebView/WebFramePrivate.h

index 0591f46..6262585 100644 (file)
@@ -1,3 +1,78 @@
+2006-08-01  Maciej Stachowiak  <mjs@apple.com>
+
+        Reviewed by Adele.
+        
+        - Change things around so WebFrameLoader tracks the main and provisional data source,
+        as well as the frame load state, pulling much code out of WebFrame along the way.
+        
+        The most significant aspects of this change are:
+        
+        - management of WebDataSources and WebFrameState was moved into WebFrameLoader
+        - there is now just one WebFrameLoader shared between the primary and provisional data source
+
+        * WebKit.xcodeproj/project.pbxproj:
+        * WebView/WebDataSource.m:
+        (-[WebDataSourcePrivate dealloc]):
+        (-[WebDataSource _updateLoading]):
+        (-[WebDataSource _loadIcon]):
+        (-[WebDataSource _setPrimaryLoadComplete:]):
+        (-[WebDataSource _stopLoading]):
+        (-[WebDataSource _startLoading]):
+        (-[WebDataSource _addSubresourceLoader:]):
+        (-[WebDataSource _removeSubresourceLoader:]):
+        (-[WebDataSource _addPlugInStreamLoader:]):
+        (-[WebDataSource _removePlugInStreamLoader:]):
+        (-[WebDataSource _defersCallbacksChanged]):
+        (-[WebDataSource _stopLoadingWithError:]):
+        (-[WebDataSource _revertToProvisionalState]):
+        (-[WebDataSource _setupForReplaceByMIMEType:]):
+        (-[WebDataSource initWithRequest:]):
+        (-[WebDataSource data]):
+        (-[WebDataSource isLoading]):
+        * WebView/WebFrame.m:
+        (-[WebFramePrivate init]):
+        (-[WebFramePrivate dealloc]):
+        (-[WebFrame _closeOldDataSources]):
+        (-[WebFrame _detachFromParent]):
+        (-[WebFrame _makeDocumentView]):
+        (-[WebFrame _receivedMainResourceError:]):
+        (-[WebFrame _transitionToCommitted:]):
+        (+[WebFrame _timeOfLastCompletedLoad]):
+        (-[WebFrame _checkLoadCompleteForThisFrame]):
+        (-[WebFrame _loadItem:withLoadType:]):
+        (-[WebFrame _continueAfterWillSubmitForm:]):
+        (-[WebFrame _continueLoadRequestAfterNavigationPolicy:formState:]):
+        (-[WebFrame _initWithWebFrameView:webView:bridge:]):
+        (-[WebFrame _frameLoader]):
+        (-[WebFrame _provisionalLoadStarted]):
+        (-[WebFrame _prepareForDataSourceReplacement]):
+        (-[WebFrame _frameLoadCompleted]):
+        (-[WebFrame provisionalDataSource]):
+        (-[WebFrame dataSource]):
+        (-[WebFrame stopLoading]):
+        * WebView/WebFrameInternal.h:
+        * WebView/WebFrameLoader.h:
+        * WebView/WebFrameLoader.m:
+        (-[WebFrameLoader initWithWebFrame:]):
+        (-[WebFrameLoader dealloc]):
+        (-[WebFrameLoader dataSource]):
+        (-[WebFrameLoader _setDataSource:]):
+        (-[WebFrameLoader clearDataSource]):
+        (-[WebFrameLoader provisionalDataSource]):
+        (-[WebFrameLoader _setProvisionalDataSource:]):
+        (-[WebFrameLoader _clearProvisionalDataSource]):
+        (-[WebFrameLoader state]):
+        (+[WebFrameLoader timeOfLastCompletedLoad]):
+        (-[WebFrameLoader _setState:]):
+        (-[WebFrameLoader clearProvisionalLoad]):
+        (-[WebFrameLoader markLoadComplete]):
+        (-[WebFrameLoader commitProvisionalLoad]):
+        (-[WebFrameLoader stopLoading]):
+        (-[WebFrameLoader startLoading]):
+        (-[WebFrameLoader startProvisionalLoad:]):
+        (-[WebFrameLoader setupForReplace]):
+        * WebView/WebFramePrivate.h:
+
 2006-08-01  Tim Omernick  <timo@apple.com>
 
         Reviewed by John Sullivan.
index da523df..23d1081 100644 (file)
                0867D690FE84028FC02AAC07 /* Project object */ = {
                        isa = PBXProject;
                        buildConfigurationList = 149C283208902B0F008A9EFC /* Build configuration list for PBXProject "WebKit" */;
+                       compatibilityVersion = "Xcode 2.4";
                        hasScannedForEncodings = 1;
                        knownRegions = (
                                English,
                        mainGroup = 0867D691FE84028FC02AAC07 /* WebKit */;
                        productRefGroup = 034768DFFF38A50411DB9C8B /* Products */;
                        projectDirPath = "";
+                       projectRoot = "";
+                       shouldCheckCompatibility = 1;
                        targets = (
                                9398100A0824BF01008DF038 /* WebKit */,
                        );
index 7b64524..195b208 100644 (file)
     WebUnarchivingState *unarchivingState;
     
     BOOL supportsMultipartContent;
-
-    WebFrameLoader *frameLoader;
 }
 
 @end
     [responses release];
     [webFrame release];
     [unarchivingState release];
-    [frameLoader release];
 
     [super dealloc];
 }
 
 - (void)_updateLoading
 {
-    [self _setLoading:[_private->frameLoader isLoading]];
+    [self _setLoading:[[_private->webFrame _frameLoader] isLoading]];
 }
 
 - (void)_setData:(NSData *)data
 {
     // Don't load an icon if 1) this is not the main frame 2) we ended in error
     // 3) we already did 4) they aren't saved by the DB.
-    if ([self webFrame] != [[self _webView] mainFrame] || _private->mainDocumentError || [_private->frameLoader hasIconLoader] ||
+    if ([self webFrame] != [[self _webView] mainFrame] || _private->mainDocumentError || [[_private->webFrame _frameLoader] hasIconLoader] ||
         ![[WebIconDatabase sharedIconDatabase] _isEnabled]) {
         return;
     }
         } else {
             NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:_private->iconURL];
             [[self webFrame] _addExtraFieldsToRequest:request mainResource:YES alwaysFromRequest:NO];
-            [_private->frameLoader loadIconWithRequest:request];
+            [[_private->webFrame _frameLoader] loadIconWithRequest:request];
             [request release];
         }
     }
         // there's no callback for that.
         [self _loadIcon];
 
-        if ([_private->frameLoader isLoadingMainResource]) {
-            [self _setData:[_private->frameLoader mainResourceData]];
-            [_private->frameLoader releaseMainResourceLoader];
+        if ([[_private->webFrame _frameLoader] isLoadingMainResource]) {
+            [self _setData:[[_private->webFrame _frameLoader] mainResourceData]];
+            [[_private->webFrame _frameLoader] releaseMainResourceLoader];
         }
         
         [self _updateLoading];
 {
     // Always attempt to stop the icon loader because it may still be loading after the data source
     // is done loading and not stopping it can cause a world leak.
-    [_private->frameLoader stopLoadingIcon];
+    [[_private->webFrame _frameLoader] stopLoadingIcon];
     
     // The same goes for the bridge/part, which may still be parsing.
     if (_private->committed)
 
     _private->stopping = YES;
     
-    if ([_private->frameLoader isLoadingMainResource]) {
+    if ([[_private->webFrame _frameLoader] isLoadingMainResource]) {
         // Stop the main resource loader and let it send the cancelled message.
-        [_private->frameLoader cancelMainResourceLoad];
-    } else if ([_private->frameLoader isLoadingSubresources]) {
+        [[_private->webFrame _frameLoader] cancelMainResourceLoad];
+    } else if ([[_private->webFrame _frameLoader] isLoadingSubresources]) {
         // The main resource loader already finished loading. Set the cancelled error on the 
         // document and let the subresourceLoaders send individual cancelled messages below.
         [self _setMainDocumentError:[self _cancelledError]];
         [self _mainReceivedError:[self _cancelledError] complete:YES];
     }
     
-    [_private->frameLoader stopLoadingSubresources];
+    [[_private->webFrame _frameLoader] stopLoadingSubresources];
     // FIXME: why not stop loading plugins here?
     
     _private->stopping = NO;
 {
     [self _prepareForLoadStart];
 
-    if ([_private->frameLoader isLoadingMainResource])
+    if ([[_private->webFrame _frameLoader] isLoadingMainResource])
         return;
 
     _private->loadingFromPageCache = NO;
     else
         identifier = [[WebDefaultResourceLoadDelegate sharedResourceLoadDelegate] webView:[self _webView] identifierForInitialRequest:_private->originalRequest fromDataSource:self];
     
-    if (![_private->frameLoader startLoadingMainResourceWithRequest:_private->request identifier:identifier])
+    if (![[_private->webFrame _frameLoader] startLoadingMainResourceWithRequest:_private->request identifier:identifier])
         [self _updateLoading];
 }
 
 - (void)_addSubresourceLoader:(WebLoader *)loader
 {
-    [_private->frameLoader addSubresourceLoader:loader];
+    [[_private->webFrame _frameLoader] addSubresourceLoader:loader];
     [self _setLoading:YES];
 }
 
 - (void)_removeSubresourceLoader:(WebLoader *)loader
 {
-    [_private->frameLoader removeSubresourceLoader:loader];
+    [[_private->webFrame _frameLoader] removeSubresourceLoader:loader];
     [self _updateLoading];
 }
 
 - (void)_addPlugInStreamLoader:(WebLoader *)loader
 {
-    [_private->frameLoader addPlugInStreamLoader:loader];
+    [[_private->webFrame _frameLoader] addPlugInStreamLoader:loader];
     [self _setLoading:YES];
 }
 
 - (void)_removePlugInStreamLoader:(WebLoader *)loader
 {
-    [_private->frameLoader removePlugInStreamLoader:loader];
+    [[_private->webFrame _frameLoader] removePlugInStreamLoader:loader];
     [self _updateLoading];
 }
 
@@ -825,7 +822,7 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class class,
     }
 
     _private->defersCallbacks = defers;
-    [_private->frameLoader setDefersCallbacks:defers];
+    [[_private->webFrame _frameLoader] setDefersCallbacks:defers];
 }
 
 - (BOOL)_defersCallbacks
@@ -998,7 +995,7 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class class,
 
 - (void)_stopLoadingWithError:(NSError *)error
 {
-    [_private->frameLoader stopLoadingWithError:error];
+    [[_private->webFrame _frameLoader] stopLoadingWithError:error];
 }
 
 - (void)_setWebFrame:(WebFrame *)frame
@@ -1032,7 +1029,7 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class class,
 - (void)_revertToProvisionalState
 {
     [self _setRepresentation:nil];
-    [[self webFrame] _setupForReplace];
+    [[_private->webFrame _frameLoader] setupForReplace];
     _private->committed = NO;
 }
 
@@ -1059,8 +1056,8 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class class,
     if ([self _doesProgressiveLoadWithMIMEType:newMIMEType])
         [self _revertToProvisionalState];
 
-    [_private->frameLoader stopLoadingSubresources];
-    [_private->frameLoader stopLoadingPlugIns];
+    [[_private->webFrame _frameLoader] stopLoadingSubresources];
+    [[_private->webFrame _frameLoader] stopLoadingPlugIns];
     [_private->unarchivingState release];
 }
 
@@ -1088,8 +1085,6 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class class,
     _private->request = [_private->originalRequest mutableCopy];
     _private->supportsMultipartContent = WKSupportsMultipartXMixedReplace(_private->request);
 
-    _private->frameLoader = [[WebFrameLoader alloc] initWithDataSource:self];
-    
     ++WebDataSourceCount;
     
     return self;
@@ -1113,7 +1108,7 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class class,
 
 - (NSData *)data
 {
-    return _private->resourceData != nil ? _private->resourceData : [_private->frameLoader mainResourceData];
+    return _private->resourceData != nil ? _private->resourceData : [[_private->webFrame _frameLoader] mainResourceData];
 }
 
 - (id <WebDocumentRepresentation>)representation
@@ -1162,10 +1157,10 @@ static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class class,
 {
     // Once a frame has loaded, we no longer need to consider subresources,
     // but we still need to consider subframes.
-    if ([[self webFrame] _state] != WebFrameStateComplete) {
+    if ([[[self webFrame] _frameLoader] state] != WebFrameStateComplete) {
         if (!_private->primaryLoadComplete && _private->loading)
             return YES;
-        if ([_private->frameLoader isLoadingSubresources])
+        if ([[_private->webFrame _frameLoader] isLoadingSubresources])
             return YES;
         if (![[[self webFrame] _bridge] doneProcessingData])
             return YES;
index 046be5a..ed95a54 100644 (file)
@@ -39,6 +39,7 @@
 #import <WebKit/WebDocumentInternal.h>
 #import <WebKit/WebFormDataStream.h>
 #import <WebKit/WebFrameLoadDelegate.h>
+#import <WebKit/WebFrameLoader.h>
 #import <WebKit/WebFrameViewInternal.h>
 #import <WebKit/WebHistoryPrivate.h>
 #import <WebKit/WebHistoryItemPrivate.h>
 
 #import <objc/objc-runtime.h>
 
-#ifndef NDEBUG
-static const char * const stateNames[] = {
-    "WebFrameStateProvisional",
-    "WebFrameStateCommittedPage",
-    "WebFrameStateComplete"
-};
-#endif
-
 /*
 Here is the current behavior matrix for four types of navigations:
 
@@ -172,10 +165,9 @@ NSString *WebPageCacheDocumentViewKey = @"WebPageCacheDocumentViewKey";
 {
 @public
     WebFrameView *webFrameView;
-    WebDataSource *dataSource;
-    WebDataSource *provisionalDataSource;
+    WebFrameLoader *frameLoader;
+
     WebFrameBridge *bridge;
-    WebFrameState state;
     WebFrameLoadType loadType;
     WebHistoryItem *currentItem;        // BF item for our current content
     WebHistoryItem *provisionalItem;    // BF item for where we're trying to go
@@ -211,10 +203,6 @@ NSString *WebPageCacheDocumentViewKey = @"WebPageCacheDocumentViewKey";
 
 - (void)setWebFrameView:(WebFrameView *)v;
 - (WebFrameView *)webFrameView;
-- (void)setDataSource:(WebDataSource *)d;
-- (WebDataSource *)dataSource;
-- (void)setProvisionalDataSource:(WebDataSource *)d;
-- (WebDataSource *)provisionalDataSource;
 - (WebFrameLoadType)loadType;
 - (void)setLoadType:(WebFrameLoadType)loadType;
 
@@ -236,7 +224,6 @@ NSString *WebPageCacheDocumentViewKey = @"WebPageCacheDocumentViewKey";
         return nil;
     }
     
-    state = WebFrameStateComplete;
     loadType = WebFrameLoadTypeStandard;
     
     return self;
@@ -245,8 +232,6 @@ NSString *WebPageCacheDocumentViewKey = @"WebPageCacheDocumentViewKey";
 - (void)dealloc
 {
     [webFrameView release];
-    [dataSource release];
-    [provisionalDataSource release];
 
     [currentItem release];
     [provisionalItem release];
@@ -276,23 +261,6 @@ NSString *WebPageCacheDocumentViewKey = @"WebPageCacheDocumentViewKey";
     webFrameView = v;
 }
 
-- (WebDataSource *)dataSource { return dataSource; }
-- (void)setDataSource: (WebDataSource *)d
-{
-    [d retain];
-    [dataSource release];
-    dataSource = d;
-}
-
-- (WebDataSource *)provisionalDataSource { return provisionalDataSource; }
-- (void)setProvisionalDataSource: (WebDataSource *)d
-{
-    ASSERT(!d || !provisionalDataSource);
-    [d retain];
-    [provisionalDataSource release];
-    provisionalDataSource = d;
-}
-
 - (WebFrameLoadType)loadType { return loadType; }
 - (void)setLoadType: (WebFrameLoadType)t
 {
@@ -551,16 +519,11 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
     for (WebFrame *child = [self _firstChildFrame]; child; child = [child _nextSiblingFrame])
         [child _closeOldDataSources];
 
-    if (_private->dataSource)
+    if ([_private->frameLoader dataSource])
         [[[self webView] _frameLoadDelegateForwarder] webView:[self webView] willCloseFrame:self];
     [[self webView] setMainFrameDocumentReady:NO];  // stop giving out the actual DOMDocument to observers
 }
 
-- (void)_clearDataSource
-{
-    [self _setDataSource:nil];
-}
-
 - (void)_detachFromParent
 {
     WebFrameBridge *bridge = [_private->bridge retain];
@@ -574,7 +537,7 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
 
     [_private->webFrameView _setWebFrame:nil]; // needed for now to be compatible w/ old behavior
 
-    [self _clearDataSource];
+    [_private->frameLoader clearDataSource];
     [_private setWebFrameView:nil];
 
     [self retain]; // retain self temporarily because dealloc can re-enter this method
@@ -590,47 +553,6 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
     [self release];
 }
 
-- (void)_setDataSource:(WebDataSource *)ds
-{
-    if (ds == nil && _private->dataSource == nil) {
-        return;
-    }
-
-    ASSERT(ds != _private->dataSource);
-
-    if (_private->dataSource) {
-        // Make sure that any work that is triggered by resigning first reponder can get done.
-        // The main example where this came up is the textDidEndEditing that is sent to the
-        // FormsDelegate (3223413).  We need to do this before _detachChildren, since that will
-        // remove the views as a side-effect of freeing the bridge, at which point we can't
-        // post the FormDelegate messages.
-        //
-        // Note that this can also take FirstResponder away from a child of our frameView that
-        // is not in a child frame's view.  This is OK because we are in the process
-        // of loading new content, which will blow away all editors in this top frame, and if
-        // a non-editor is firstReponder it will not be affected by endEditingFor:.
-        // Potentially one day someone could write a DocView whose editors were not all
-        // replaced by loading new content, but that does not apply currently.
-        NSView *frameView = [self frameView];
-        NSWindow *window = [frameView window];
-        NSResponder *firstResp = [window firstResponder];
-        if ([firstResp isKindOfClass:[NSView class]]
-            && [(NSView *)firstResp isDescendantOf:frameView])
-        {
-            [window endEditingFor:firstResp];
-        }
-
-        [self _detachChildren];
-
-        [_private->dataSource _setWebFrame:nil];
-    } else {
-        ASSERT(![self _childFrameCount]);
-    }
-
-    [_private setDataSource:ds];
-    [ds _setWebFrame:self];
-}
-
 - (void)_setLoadType: (WebFrameLoadType)t
 {
     [_private setLoadType:t];
@@ -643,10 +565,9 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
 
 - (void)_makeDocumentView
 {
-    NSView <WebDocumentView> *documentView = [_private->webFrameView _makeDocumentViewForDataSource:_private->dataSource];
-    if (!documentView) {
+    NSView <WebDocumentView> *documentView = [_private->webFrameView _makeDocumentViewForDataSource:[_private->frameLoader dataSource]];
+    if (!documentView)
         return;
-    }
 
     // FIXME: We could save work and not do this for a top-level view that is not a WebHTMLView.
     WebFrameView *v = _private->webFrameView;
@@ -656,13 +577,13 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
 
     // Call setDataSource on the document view after it has been placed in the view hierarchy.
     // This what we for the top-level view, so should do this for views in subframes as well.
-    [documentView setDataSource:_private->dataSource];
+    [documentView setDataSource:[_private->frameLoader dataSource]];
 }
 
 - (void)_receivedMainResourceError:(NSError *)error
 {
-    if ([self _state] == WebFrameStateProvisional) {
-        NSURL *failedURL = [[_private->provisionalDataSource _originalRequest] URL];
+    if ([_private->frameLoader state] == WebFrameStateProvisional) {
+        NSURL *failedURL = [[[_private->frameLoader provisionalDataSource] _originalRequest] URL];
         // When we are pre-commit, the currentItem is where the pageCache data resides
         NSDictionary *pageCache = [[_private currentItem] pageCache];
         [[self _bridge] didNotOpenURL:failedURL pageCache:pageCache];
@@ -679,18 +600,11 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
     }
 }
 
-- (void)_commitProvisionalLoad
-{
-    [self _setDataSource:_private->provisionalDataSource];
-    [self _setProvisionalDataSource: nil];
-    [self _setState:WebFrameStateCommittedPage];
-}
-
 - (void)_transitionToCommitted:(NSDictionary *)pageCache
 {
     ASSERT([self webView] != nil);
     
-    switch ([self _state]) {
+    switch ([_private->frameLoader state]) {
         case WebFrameStateProvisional:
         {
             [[[[self frameView] _scrollView] contentView] setCopiesOnScroll:YES];
@@ -699,7 +613,7 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
             if (loadType == WebFrameLoadTypeForward ||
                 loadType == WebFrameLoadTypeBack ||
                 loadType == WebFrameLoadTypeIndexedBackForward ||
-                (loadType == WebFrameLoadTypeReload && [_private->provisionalDataSource unreachableURL] != nil))
+                (loadType == WebFrameLoadTypeReload && [[_private->frameLoader provisionalDataSource] unreachableURL] != nil))
             {
                 // Once committed, we want to use current item for saving DocState, and
                 // the provisional item for restoring state.
@@ -714,12 +628,12 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
             // The call to closeURL invokes the unload event handler, which can execute arbitrary
             // JavaScript. If the script initiates a new load, we need to abandon the current load,
             // or the two will stomp each other.
-            WebDataSource *pd = _private->provisionalDataSource;
+            WebDataSource *pd = [_private->frameLoader provisionalDataSource];
             [[self _bridge] closeURL];
-            if (pd != _private->provisionalDataSource)
+            if (pd != [_private->frameLoader provisionalDataSource])
                 return;
 
-            [self _commitProvisionalLoad];
+            [_private->frameLoader commitProvisionalLoad];
 
             // Handle adding the URL to the back/forward list.
             WebDataSource *ds = [self dataSource];
@@ -933,15 +847,9 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
     }
 }
 
-- (WebFrameState)_state
-{
-    return _private->state;
-}
-
-static CFAbsoluteTime _timeOfLastCompletedLoad;
 + (CFAbsoluteTime)_timeOfLastCompletedLoad
 {
-    return _timeOfLastCompletedLoad;
+    return [WebFrameLoader timeOfLastCompletedLoad];
 }
 
 - (BOOL)_createPageCacheForItem:(WebHistoryItem *)item
@@ -963,85 +871,6 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
     return YES;
 }
 
-- (void)_setState: (WebFrameState)newState
-{
-    LOG(Loading, "%@:  transition from %s to %s", [self name], stateNames[_private->state], stateNames[newState]);
-    if ([self webView])
-        LOG(Timing, "%@:  transition from %s to %s, %f seconds since start of document load", [self name], stateNames[_private->state], stateNames[newState], CFAbsoluteTimeGetCurrent() - [[[[self webView] mainFrame] dataSource] _loadingStartedTime]);
-    
-    if (newState == WebFrameStateComplete && self == [[self webView] mainFrame]){
-        LOG(DocumentLoad, "completed %@ (%f seconds)", [[[self dataSource] request] URL], CFAbsoluteTimeGetCurrent() - [[self dataSource] _loadingStartedTime]);
-    }
-    
-    _private->state = newState;
-    
-    if (_private->state == WebFrameStateProvisional) {
-        _private->firstLayoutDone = NO;
-        [_private->bridge provisionalLoadStarted];
-    
-        // FIXME: This is OK as long as no one resizes the window,
-        // but in the case where someone does, it means garbage outside
-        // the occupied part of the scroll view.
-        [[[self frameView] _scrollView] setDrawsBackground:NO];
-
-        // Cache the page, if possible.
-        // Don't write to the cache if in the middle of a redirect, since we will want to
-        // store the final page we end up on.
-        // No point writing to the cache on a reload or loadSame, since we will just write
-        // over it again when we leave that page.
-        WebHistoryItem *item = [_private currentItem];
-        WebFrameLoadType loadType = [self _loadType];
-        if ([self _canCachePage]
-            && [_private->bridge canCachePage]
-            && item
-            && !_private->quickRedirectComing
-            && loadType != WebFrameLoadTypeReload 
-            && loadType != WebFrameLoadTypeReloadAllowingStaleData
-            && loadType != WebFrameLoadTypeSame
-            && ![[self dataSource] isLoading]
-            && ![[self dataSource] _isStopping])
-        {
-            if ([[[self dataSource] representation] isKindOfClass: [WebHTMLRepresentation class]]) {
-                if (![item pageCache]){
-
-                    // Add the items to this page's cache.
-                    if ([self _createPageCacheForItem:item]) {
-                        LOG(PageCache, "Saving page to back/forward cache, %@\n", [[self dataSource] _URL]);
-
-                        // See if any page caches need to be purged after the addition of this
-                        // new page cache.
-                        [self _purgePageCache];
-                    }
-                    else {
-                        LOG(PageCache, "NOT saving page to back/forward cache, unable to create items, %@\n", [[self dataSource] _URL]);
-                    }
-                }
-            }
-            else {
-                // Put the document into a null state, so it can be restored correctly.
-                [_private->bridge clear];
-            }
-        }
-        else {
-            LOG(PageCache, "NOT saving page to back/forward cache, %@\n", [[self dataSource] _URL]);
-        }
-    }
-    
-    if (_private->state == WebFrameStateComplete) {
-        NSScrollView *sv = [[self frameView] _scrollView];
-        if ([[self webView] drawsBackground])
-            [sv setDrawsBackground:YES];
-        [_private setPreviousItem:nil];
-        _timeOfLastCompletedLoad = CFAbsoluteTimeGetCurrent();
-
-        [[self dataSource] _stopRecordingResponses];
-
-        // After a canceled provisional load, firstLayoutDone is NO. Reset it to YES if we're displaying a page.
-        if (_private->dataSource)
-            _private->firstLayoutDone = YES;
-    }
-}
-
 // Called after we send an openURL:... down to WebCore.
 - (void)_opened
 {
@@ -1088,23 +917,11 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
     }
 }
 
-- (void)_clearProvisionalLoad
-{
-    [self _setProvisionalDataSource:nil];
-    [[self webView] _progressCompleted:self];
-    [self _setState:WebFrameStateComplete];
-}
-
-- (void)_markLoadComplete
-{
-    [self _setState:WebFrameStateComplete];
-}
-
 - (void)_checkLoadCompleteForThisFrame
 {
     ASSERT([self webView] != nil);
 
-    switch ([self _state]) {
+    switch ([_private->frameLoader state]) {
         case WebFrameStateProvisional:
         {
             if (_private->delegateIsHandlingProvisionalLoadError)
@@ -1140,10 +957,10 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
 
                     // Finish resetting the load state, but only if another load hasn't been started by the
                     // delegate callback.
-                    if (pd == _private->provisionalDataSource) {
-                        [self _clearProvisionalLoad];
-                    else {
-                        NSURL *unreachableURL = [_private->provisionalDataSource unreachableURL];
+                    if (pd == [_private->frameLoader provisionalDataSource])
+                        [_private->frameLoader clearProvisionalLoad];
+                    else {
+                        NSURL *unreachableURL = [[_private->frameLoader provisionalDataSource] unreachableURL];
                         if (unreachableURL != nil && [unreachableURL isEqual:[[pd request] URL]]) {
                             shouldReset = NO;
                         }
@@ -1166,7 +983,7 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
                 NSView <WebDocumentView> *thisDocumentView = [thisView documentView];
                 ASSERT(thisDocumentView != nil);
 
-                [self _markLoadComplete];
+                [_private->frameLoader markLoadComplete];
 
                 // FIXME: Is this subsequent work important if we already navigated away?
                 // Maybe there are bugs because of that, or extra work we can skip because
@@ -1269,11 +1086,6 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
     _private->delegateIsHandlingUnimplementablePolicy = NO;
 }
 
-- (void)_clearProvisionalDataSource
-{
-    [self _setProvisionalDataSource:nil];
-}
-
 // helper method that determines whether the subframes described by the item's subitems
 // match our own current frameset
 - (BOOL)_childFramesMatchItem:(WebHistoryItem *)item
@@ -1354,7 +1166,7 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
 
         // We always call scrollToAnchorWithURL here, even if the URL doesn't have an
         // anchor fragment. This is so we'll keep the WebCore Frame's URL up-to-date.
-        [[_private->dataSource _bridge] scrollToAnchorWithURL:[item URL]];
+        [_private->bridge scrollToAnchorWithURL:[item URL]];
     
         // must do this maintenance here, since we don't go through a real page reload
         [_private setCurrentItem:item];
@@ -2265,13 +2077,7 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
         [_private->listener release];
         _private->listener = nil;
     }
-    [_private->provisionalDataSource _startLoading];
-}
-
-- (void)_startProvisionalLoad:(WebDataSource *)dataSource
-{
-    [self _setProvisionalDataSource:dataSource];
-    [self _setState:WebFrameStateProvisional];
+    [_private->frameLoader startLoading];
 }
 
 -(void)_continueLoadRequestAfterNavigationPolicy:(NSURLRequest *)request formState:(WebFormState *)formState
@@ -2314,7 +2120,7 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
     [self stopLoading];
     [self _setLoadType:loadType];
 
-    [self _startProvisionalLoad:dataSource];
+    [_private->frameLoader startProvisionalLoad:dataSource];
 
     [dataSource release];
     [self _setPolicyDataSource:nil];
@@ -2330,7 +2136,7 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
         NSDictionary *pageCache = [[_private provisionalItem] pageCache];
         if ([pageCache objectForKey:WebCorePageCacheStateKey]){
             LOG (PageCache, "Restoring page from back/forward cache, %@\n", [[_private provisionalItem] URL]);
-            [_private->provisionalDataSource _loadFromPageCache:pageCache];
+            [[_private->frameLoader provisionalDataSource] _loadFromPageCache:pageCache];
             return;
         }
     }
@@ -2373,15 +2179,6 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
                               withSelector:@selector(_continueLoadRequestAfterNavigationPolicy:formState:)];
 }
 
-- (void)_setProvisionalDataSource: (WebDataSource *)d
-{
-    if (_private->provisionalDataSource != _private->dataSource) {
-        [_private->provisionalDataSource _setWebFrame:nil];
-    }
-    [_private setProvisionalDataSource: d];
-    [d _setWebFrame:self];
-}
-
 // used to decide to use loadType=Same
 - (BOOL)_shouldTreatURLAsSameAsCurrent:(NSURL *)URL
 {
@@ -2513,6 +2310,8 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
         [fv _setWebFrame:self];
     }
     
+    _private->frameLoader = [[WebFrameLoader alloc] initWithWebFrame:self];
+    
     ++WebFrameCount;
     
     return self;
@@ -2657,16 +2456,6 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
     _private->firstLayoutDone = YES;
 }
 
-- (void)_setupForReplace
-{
-    [self _setState:WebFrameStateProvisional];
-    WebDataSource *old = _private->provisionalDataSource;
-    _private->provisionalDataSource = _private->dataSource;
-    _private->dataSource = nil;
-    [old release];
-        
-    [self _detachChildren];
-}
 
 - (BOOL)_hasSelection
 {
@@ -2812,6 +2601,100 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
     [_private->inspectors removeObject:inspector];
 }
 
+- (WebFrameLoader *)_frameLoader
+{
+    return _private->frameLoader;
+}
+
+- (void)_provisionalLoadStarted
+{
+    _private->firstLayoutDone = NO;
+    [_private->bridge provisionalLoadStarted];
+    
+    // FIXME: This is OK as long as no one resizes the window,
+    // but in the case where someone does, it means garbage outside
+    // the occupied part of the scroll view.
+    [[[self frameView] _scrollView] setDrawsBackground:NO];
+    
+    // Cache the page, if possible.
+    // Don't write to the cache if in the middle of a redirect, since we will want to
+    // store the final page we end up on.
+    // No point writing to the cache on a reload or loadSame, since we will just write
+    // over it again when we leave that page.
+    WebHistoryItem *item = [_private currentItem];
+    WebFrameLoadType loadType = [self _loadType];
+    if ([self _canCachePage]
+        && [_private->bridge canCachePage]
+    && item
+    && !_private->quickRedirectComing
+    && loadType != WebFrameLoadTypeReload 
+    && loadType != WebFrameLoadTypeReloadAllowingStaleData
+    && loadType != WebFrameLoadTypeSame
+    && ![[self dataSource] isLoading]
+    && ![[self dataSource] _isStopping]) {
+        if ([[[self dataSource] representation] isKindOfClass: [WebHTMLRepresentation class]]) {
+            if (![item pageCache]){
+                
+                // Add the items to this page's cache.
+                if ([self _createPageCacheForItem:item]) {
+                    LOG(PageCache, "Saving page to back/forward cache, %@\n", [[self dataSource] _URL]);
+                    
+                    // See if any page caches need to be purged after the addition of this
+                    // new page cache.
+                    [self _purgePageCache];
+                }
+                else
+                    LOG(PageCache, "NOT saving page to back/forward cache, unable to create items, %@\n", [[self dataSource] _URL]);
+            }
+        } else
+            // Put the document into a null state, so it can be restored correctly.
+            [_private->bridge clear];
+    } else
+        LOG(PageCache, "NOT saving page to back/forward cache, %@\n", [[self dataSource] _URL]);
+}
+
+- (void)_prepareForDataSourceReplacement
+{
+    if (![_private->frameLoader dataSource]) {
+        ASSERT(![self _childFrameCount]);
+        return;
+    }
+    
+    // Make sure that any work that is triggered by resigning first reponder can get done.
+    // The main example where this came up is the textDidEndEditing that is sent to the
+    // FormsDelegate (3223413).  We need to do this before _detachChildren, since that will
+    // remove the views as a side-effect of freeing the bridge, at which point we can't
+    // post the FormDelegate messages.
+    //
+    // Note that this can also take FirstResponder away from a child of our frameView that
+    // is not in a child frame's view.  This is OK because we are in the process
+    // of loading new content, which will blow away all editors in this top frame, and if
+    // a non-editor is firstReponder it will not be affected by endEditingFor:.
+    // Potentially one day someone could write a DocView whose editors were not all
+    // replaced by loading new content, but that does not apply currently.
+    NSView *frameView = [self frameView];
+    NSWindow *window = [frameView window];
+    NSResponder *firstResp = [window firstResponder];
+    if ([firstResp isKindOfClass:[NSView class]]
+        && [(NSView *)firstResp isDescendantOf:frameView])
+    {
+        [window endEditingFor:firstResp];
+    }
+    
+    [self _detachChildren];
+}
+
+- (void)_frameLoadCompleted
+{
+    NSScrollView *sv = [[self frameView] _scrollView];
+    if ([[self webView] drawsBackground])
+        [sv setDrawsBackground:YES];
+    [_private setPreviousItem:nil];
+    // After a canceled provisional load, firstLayoutDone is NO. Reset it to YES if we're displaying a page.
+    if ([_private->frameLoader dataSource])
+        _private->firstLayoutDone = YES;
+}
+
 @end
 
 @implementation WebFormState : NSObject
@@ -2912,12 +2795,12 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
 
 - (WebDataSource *)provisionalDataSource
 {
-    return [_private provisionalDataSource];
+    return [_private->frameLoader provisionalDataSource];
 }
 
 - (WebDataSource *)dataSource
 {
-    return [_private dataSource];
+    return [_private->frameLoader dataSource];
 }
 
 - (void)loadRequest:(NSURLRequest *)request
@@ -2995,10 +2878,7 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
     [self _invalidatePendingPolicyDecisionCallingDefaultAction:YES];
 
     [self _stopLoadingSubframes];
-    [_private->provisionalDataSource _stopLoading];
-    [_private->dataSource _stopLoading];
-
-    [self _clearProvisionalDataSource];
+    [_private->frameLoader stopLoading];
 
     _private->isStoppingLoad = NO;
 }
index 07939fe..b541f45 100644 (file)
@@ -31,6 +31,7 @@
 #import <WebKit/WebFramePrivate.h>
 
 @class WebInspector;
+@class WebFrameLoader;
 
 @interface WebFrame (WebInternal)
 
@@ -45,7 +46,6 @@
 - (NSURLRequest *)_requestFromDelegateForRequest:(NSURLRequest *)request identifier:(id *)identifier error:(NSError **)error;
 - (void)_sendRemainingDelegateMessagesWithIdentifier:(id)identifier response:(NSURLResponse *)response length:(unsigned)length error:(NSError *)error;
 - (void)_safeLoadURL:(NSURL *)URL;
-- (void)_setupForReplace;
 
 - (BOOL)_hasSelection;
 - (void)_clearSelection;
 
 - (void)_addInspector:(WebInspector *)inspector;
 - (void)_removeInspector:(WebInspector *)inspector;
+
+- (WebFrameLoader *)_frameLoader;
+- (void)_provisionalLoadStarted;
+- (void)_prepareForDataSourceReplacement;
+- (void)_frameLoadCompleted;
+
 @end
 
 @interface NSObject (WebInternalFrameLoadDelegate)
index f503837..3ad7250 100644 (file)
@@ -27,6 +27,7 @@
  */
 
 #import <Cocoa/Cocoa.h>
+#import <WebKit/WebFramePrivate.h>
 
 @class WebDataSource;
 @class WebMainResourceLoader;
     NSMutableArray *plugInStreamLoaders;
     WebIconLoader *iconLoader;
     
+    WebFrame *webFrame;
     WebDataSource *dataSource;
+    WebDataSource *provisionalDataSource;
+    WebFrameState state;
 }
 
-- (id)initWithDataSource:(WebDataSource *)ds;
+- (id)initWithWebFrame:(WebFrame *)wf;
 // FIXME: should really split isLoadingIcon from hasLoadedIcon, no?
 - (BOOL)hasIconLoader;
 - (void)loadIconWithRequest:(NSURLRequest *)request;
 - (void)cancelMainResourceLoad;
 - (BOOL)startLoadingMainResourceWithRequest:(NSMutableURLRequest *)request identifier:(id)identifier;
 - (void)stopLoadingWithError:(NSError *)error;
+- (void)clearProvisionalLoad;
+- (void)stopLoading;
+- (void)markLoadComplete;
+- (void)commitProvisionalLoad;
+- (void)startLoading;
+- (void)startProvisionalLoad:(WebDataSource *)dataSource;
+- (WebDataSource *)dataSource;
+- (WebDataSource *)provisionalDataSource;
+- (WebFrameState)state;
+- (void)clearDataSource;
+- (void)setupForReplace;
++ (CFAbsoluteTime)timeOfLastCompletedLoad;
 
 @end
index 80e719a..55fc70b 100644 (file)
 #import <WebKit/WebFrameLoader.h>
 
 #import <JavaScriptCore/Assertions.h>
-#import <WebKit/WebDataSource.h>
+#import <WebKit/WebDataSourceInternal.h>
 #import <WebKit/WebFrameInternal.h>
 #import <WebKit/WebIconLoader.h>
 #import <WebKit/WebMainResourceLoader.h>
+#import <WebKit/WebKitLogging.h>
+#import <WebKit/WebViewInternal.h>
 
 @implementation WebFrameLoader
 
-- (id)initWithDataSource:(WebDataSource *)ds
+- (id)initWithWebFrame:(WebFrame *)wf
 {
     self = [super init];
-    if (self)
-        dataSource = ds;
+    if (self) {
+        webFrame = wf;
+        state = WebFrameStateCommittedPage;
+    }
     return self;    
 }
 
@@ -51,6 +55,9 @@
     [subresourceLoaders release];
     [plugInStreamLoaders release];
     [iconLoader release];
+    [dataSource release];
+    [provisionalDataSource release];
+    
     [super dealloc];
 }
 
 
 - (BOOL)startLoadingMainResourceWithRequest:(NSMutableURLRequest *)request identifier:(id)identifier
 {
-    mainResourceLoader = [[WebMainResourceLoader alloc] initWithDataSource:dataSource];
+    mainResourceLoader = [[WebMainResourceLoader alloc] initWithDataSource:provisionalDataSource];
     
     [mainResourceLoader setIdentifier:identifier];
-    [[dataSource webFrame] _addExtraFieldsToRequest:request mainResource:YES alwaysFromRequest:NO];
+    [[provisionalDataSource webFrame] _addExtraFieldsToRequest:request mainResource:YES alwaysFromRequest:NO];
     if (![mainResourceLoader loadWithRequest:request]) {
         // FIXME: if this should really be caught, we should just ASSERT this doesn't happen;
         // should it be caught by other parts of WebKit or other parts of the app?
     [mainResourceLoader cancelWithError:error];
 }
 
+- (WebDataSource *)dataSource
+{
+    return dataSource; 
+}
+
+- (void)_setDataSource:(WebDataSource *)ds
+{
+    if (ds == nil && dataSource == nil)
+        return;
+    
+    ASSERT(ds != dataSource);
+    
+    [webFrame _prepareForDataSourceReplacement];
+    [dataSource _setWebFrame:nil];
+    
+    [ds retain];
+    [dataSource release];
+    dataSource = ds;
+
+    [ds _setWebFrame:webFrame];
+}
+
+- (void)clearDataSource
+{
+    [self _setDataSource:nil];
+}
+
+- (WebDataSource *)provisionalDataSource 
+{
+    return provisionalDataSource; 
+}
+
+- (void)_setProvisionalDataSource: (WebDataSource *)d
+{
+    ASSERT(!d || !provisionalDataSource);
+
+    if (provisionalDataSource != dataSource)
+        [provisionalDataSource _setWebFrame:nil];
+
+    [d retain];
+    [provisionalDataSource release];
+    provisionalDataSource = d;
+
+    [d _setWebFrame:webFrame];
+}
+
+- (void)_clearProvisionalDataSource
+{
+    [self _setProvisionalDataSource:nil];
+}
+
+- (WebFrameState)state
+{
+    return state;
+}
+
+#ifndef NDEBUG
+static const char * const stateNames[] = {
+    "WebFrameStateProvisional",
+    "WebFrameStateCommittedPage",
+    "WebFrameStateComplete"
+};
+#endif
+
+static CFAbsoluteTime _timeOfLastCompletedLoad;
+
++ (CFAbsoluteTime)timeOfLastCompletedLoad
+{
+    return _timeOfLastCompletedLoad;
+}
+
+- (void)_setState:(WebFrameState)newState
+{
+    LOG(Loading, "%@:  transition from %s to %s", [webFrame name], stateNames[state], stateNames[newState]);
+    if ([webFrame webView])
+        LOG(Timing, "%@:  transition from %s to %s, %f seconds since start of document load", [webFrame name], stateNames[state], stateNames[newState], CFAbsoluteTimeGetCurrent() - [[[[webFrame webView] mainFrame] dataSource] _loadingStartedTime]);
+    
+    if (newState == WebFrameStateComplete && webFrame == [[webFrame webView] mainFrame])
+        LOG(DocumentLoad, "completed %@ (%f seconds)", [[[self dataSource] request] URL], CFAbsoluteTimeGetCurrent() - [[self dataSource] _loadingStartedTime]);
+    
+    state = newState;
+    
+    if (state == WebFrameStateProvisional)
+        [webFrame _provisionalLoadStarted];
+    else if (state == WebFrameStateComplete) {
+        [webFrame _frameLoadCompleted];
+        _timeOfLastCompletedLoad = CFAbsoluteTimeGetCurrent();
+        [dataSource _stopRecordingResponses];
+    }
+}
+
+- (void)clearProvisionalLoad
+{
+    [self _setProvisionalDataSource:nil];
+    [[webFrame webView] _progressCompleted:webFrame];
+    [self _setState:WebFrameStateComplete];
+}
+
+- (void)markLoadComplete
+{
+    [self _setState:WebFrameStateComplete];
+}
+
+- (void)commitProvisionalLoad
+{
+    [self stopLoadingSubresources];
+    [self stopLoadingPlugIns];
+
+    [self _setDataSource:provisionalDataSource];
+    [self _setProvisionalDataSource:nil];
+    [self _setState:WebFrameStateCommittedPage];
+}
+
+- (void)stopLoading
+{
+    [provisionalDataSource _stopLoading];
+    [dataSource _stopLoading];
+    [self _clearProvisionalDataSource];
+}
+
+// FIXME: poor method name; also why is this not part of startProvisionalLoad:?
+- (void)startLoading
+{
+    [provisionalDataSource _startLoading];
+}
+
+- (void)startProvisionalLoad:(WebDataSource *)ds
+{
+    [self _setProvisionalDataSource:ds];
+    [self _setState:WebFrameStateProvisional];
+}
+
+- (void)setupForReplace
+{
+    [self _setState:WebFrameStateProvisional];
+    WebDataSource *old = provisionalDataSource;
+    provisionalDataSource = dataSource;
+    dataSource = nil;
+    [old release];
+    
+    [webFrame _detachChildren];
+}
+
 @end
index c29753c..b501dc4 100644 (file)
@@ -83,15 +83,11 @@ extern NSString *WebPageCacheDocumentViewKey;
 - (void)_detachFromParent;
 - (void)_detachChildren;
 - (void)_closeOldDataSources;
-- (void)_setDataSource:(WebDataSource *)d;
 - (void)_commitProvisionalLoad:(NSDictionary *)pageCache;
-- (WebFrameState)_state;
-- (void)_setState:(WebFrameState)newState;
 - (void)_checkLoadCompleteForThisFrame;
 - (void)_handledOnloadEvents;
 - (void)_checkLoadComplete;
 - (WebFrameBridge *)_bridge;
-- (void)_clearProvisionalDataSource;
 - (void)_setLoadType:(WebFrameLoadType)loadType;
 - (WebFrameLoadType)_loadType;
 
@@ -134,8 +130,6 @@ extern NSString *WebPageCacheDocumentViewKey;
 
 - (void)_loadDataSource:(WebDataSource *)dataSource withLoadType:(WebFrameLoadType)type formState:(WebFormState *)formState;
 
-- (void)_setProvisionalDataSource:(WebDataSource *)d;
-
 + (CFAbsoluteTime)_timeOfLastCompletedLoad;
 - (BOOL)_canCachePage;
 - (void)_purgePageCache;