Reviewed by Darin.
authormjs <mjs@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 8 Oct 2006 23:52:05 +0000 (23:52 +0000)
committermjs <mjs@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 8 Oct 2006 23:52:05 +0000 (23:52 +0000)
        - remove unneeded non-Loader header includes from WebFrameLoader.h (split WebFrameLoadType into
        two coincidentally matching enums)

        * Loader/WebFrameLoader.h:
        * Loader/WebFrameLoader.m:
        (-[WebFrameLoader loadURL:referrer:loadType:target:triggeringEvent:form:formValues:]):
        (-[WebFrameLoader commitProvisionalLoad:]):
        (isBackForwardLoadType):
        (-[WebFrameLoader _loadRequest:archive:]):
        (-[WebFrameLoader _loadRequest:triggeringAction:loadType:formState:]):
        (-[WebFrameLoader _reloadAllowingStaleDataWithOverrideEncoding:]):
        (-[WebFrameLoader reload]):
        (-[WebFrameLoader isReplacing]):
        (-[WebFrameLoader setReplacing]):
        (-[WebFrameLoader loadType]):
        (-[WebFrameLoader setLoadType:]):
        (-[WebFrameLoader checkNavigationPolicyForRequest:dataSource:formState:andCall:withSelector:]):
        (-[WebFrameLoader continueLoadRequestAfterNavigationPolicy:formState:]):
        (-[WebFrameLoader loadDataSource:withLoadType:formState:]):
        (-[WebFrameLoader didFirstLayout]):
        * WebCoreSupport/WebFrameBridge.m:
        * WebView/WebFrame.m:
        (-[WebFrame _transitionToCommitted:]):
        (-[WebFrame _provisionalLoadStarted]):
        (-[WebFrame _opened]):
        (-[WebFrame _checkLoadCompleteForThisFrame]):
        (-[WebFrame _loadItem:withLoadType:]):
        (-[WebFrame _recursiveGoToItem:fromItem:withLoadType:]):
        (-[WebFrame _goToItem:withLoadType:]):
        (-[WebFrame _actionInformationForLoadType:isFormSubmission:event:originalURL:]):
        (-[WebFrame _continueLoadRequestAfterNewWindowPolicy:frameName:formState:]):
        (-[WebFrame _loadURL:referrer:intoChild:]):
        (-[WebFrame _postWithURL:referrer:target:data:contentType:triggeringEvent:form:formValues:]):
        (-[WebFrame _currentBackForwardListItemToResetTo]):
        (-[WebFrame _itemForRestoringDocState]):
        (-[WebFrame _addExtraFieldsToRequest:mainResource:alwaysFromRequest:]):
        (-[WebFrame _loadType]):
        (-[WebFrame loadRequest:]):
        * WebView/WebFrameInternal.h:
        * WebView/WebView.m:

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

WebKit/ChangeLog
WebKit/Loader/WebFrameLoader.h
WebKit/Loader/WebFrameLoader.m
WebKit/Plugins/WebPluginController.m
WebKit/WebCoreSupport/WebFrameBridge.m
WebKit/WebView/WebFrame.m
WebKit/WebView/WebFrameInternal.h
WebKit/WebView/WebView.m

index 90a2088a86f463725e1ace5c7131552020683274..bea604fe15cda48fd351dc9d29bb358bb726c788 100644 (file)
@@ -1,3 +1,48 @@
+2006-10-08  Maciej Stachowiak  <mjs@apple.com>
+
+        Reviewed by Darin.
+        
+        - remove unneeded non-Loader header includes from WebFrameLoader.h (split WebFrameLoadType into
+        two coincidentally matching enums)
+
+        * Loader/WebFrameLoader.h:
+        * Loader/WebFrameLoader.m:
+        (-[WebFrameLoader loadURL:referrer:loadType:target:triggeringEvent:form:formValues:]):
+        (-[WebFrameLoader commitProvisionalLoad:]):
+        (isBackForwardLoadType):
+        (-[WebFrameLoader _loadRequest:archive:]):
+        (-[WebFrameLoader _loadRequest:triggeringAction:loadType:formState:]):
+        (-[WebFrameLoader _reloadAllowingStaleDataWithOverrideEncoding:]):
+        (-[WebFrameLoader reload]):
+        (-[WebFrameLoader isReplacing]):
+        (-[WebFrameLoader setReplacing]):
+        (-[WebFrameLoader loadType]):
+        (-[WebFrameLoader setLoadType:]):
+        (-[WebFrameLoader checkNavigationPolicyForRequest:dataSource:formState:andCall:withSelector:]):
+        (-[WebFrameLoader continueLoadRequestAfterNavigationPolicy:formState:]):
+        (-[WebFrameLoader loadDataSource:withLoadType:formState:]):
+        (-[WebFrameLoader didFirstLayout]):
+        * WebCoreSupport/WebFrameBridge.m:
+        * WebView/WebFrame.m:
+        (-[WebFrame _transitionToCommitted:]):
+        (-[WebFrame _provisionalLoadStarted]):
+        (-[WebFrame _opened]):
+        (-[WebFrame _checkLoadCompleteForThisFrame]):
+        (-[WebFrame _loadItem:withLoadType:]):
+        (-[WebFrame _recursiveGoToItem:fromItem:withLoadType:]):
+        (-[WebFrame _goToItem:withLoadType:]):
+        (-[WebFrame _actionInformationForLoadType:isFormSubmission:event:originalURL:]):
+        (-[WebFrame _continueLoadRequestAfterNewWindowPolicy:frameName:formState:]):
+        (-[WebFrame _loadURL:referrer:intoChild:]):
+        (-[WebFrame _postWithURL:referrer:target:data:contentType:triggeringEvent:form:formValues:]):
+        (-[WebFrame _currentBackForwardListItemToResetTo]):
+        (-[WebFrame _itemForRestoringDocState]):
+        (-[WebFrame _addExtraFieldsToRequest:mainResource:alwaysFromRequest:]):
+        (-[WebFrame _loadType]):
+        (-[WebFrame loadRequest:]):
+        * WebView/WebFrameInternal.h:
+        * WebView/WebView.m:
+
 2006-10-08  Darin Adler  <darin@apple.com>
 
         Reviewed by Maciej.
index 75311999e349c6a1d15ca6c93b1b6d83f7ff6eab..1a4d370c6ec44715dc6dc6f5f98e3a2af903d6bf 100644 (file)
 
 #import <Cocoa/Cocoa.h>
 
-#import "WebDocumentLoader.h"
-#import "WebFrameLoaderClient.h"
-#import "WebFramePrivate.h"
-
+@class DOMElement;
 @class WebArchive;
 @class WebDataSource;
+@class WebDocumentLoader;
 @class WebFormState;
+@class WebFrame;
+@class WebFrame;
 @class WebFrameBridge;
-@class WebMainResourceLoader;
 @class WebLoader;
-@class WebResource;
-@class WebFrame;
+@class WebMainResourceLoader;
 @class WebPolicyDecisionListener;
-@class DOMElement;
+@class WebResource;
+@protocol WebFrameLoaderClient;
 
 typedef enum {
     WebFrameStateProvisional,
@@ -59,6 +58,18 @@ typedef enum {
     WebPolicyIgnore,
 } WebPolicyAction;
 
+typedef enum {
+    FrameLoadTypeStandard,
+    FrameLoadTypeBack,
+    FrameLoadTypeForward,
+    FrameLoadTypeIndexedBackForward, // a multi-item hop in the backforward list
+    FrameLoadTypeReload,
+    FrameLoadTypeReloadAllowingStaleData,
+    FrameLoadTypeSame,               // user loads same URL again (but not reload button)
+    FrameLoadTypeInternal,
+    FrameLoadTypeReplace
+} FrameLoadType;
+
 @interface WebFrameLoader : NSObject
 {
 @public
@@ -78,7 +89,7 @@ typedef enum {
     
     NSMutableDictionary *pendingArchivedResources;
 
-    WebFrameLoadType loadType;
+    FrameLoadType loadType;
 
     // state we'll need to continue after waiting for the policy delegate's decision
     NSURLRequest *policyRequest;
@@ -86,7 +97,7 @@ typedef enum {
     id policyTarget;
     SEL policySelector;
     WebFormState *policyFormState;
-    WebFrameLoadType policyLoadType;
+    FrameLoadType policyLoadType;
 
     BOOL delegateIsHandlingProvisionalLoadError;
     BOOL delegateIsDecidingNavigationPolicy;
@@ -187,7 +198,7 @@ typedef enum {
 - (void)_loadRequest:(NSURLRequest *)request archive:(WebArchive *)archive;
 - (void)reload;
 - (void)_reloadAllowingStaleDataWithOverrideEncoding:(NSString *)encoding;
-- (void)_loadRequest:(NSURLRequest *)request triggeringAction:(NSDictionary *)action loadType:(WebFrameLoadType)loadType formState:(WebFormState *)formState;
+- (void)_loadRequest:(NSURLRequest *)request triggeringAction:(NSDictionary *)action loadType:(FrameLoadType)loadType formState:(WebFormState *)formState;
 
 - (void)didReceiveServerRedirectForProvisionalLoadForFrame;
 - (WebFrameBridge *)bridge;
@@ -204,8 +215,8 @@ typedef enum {
 - (void)willChangeTitleForDocument:(WebDocumentLoader *)loader;
 - (void)didChangeTitleForDocument:(WebDocumentLoader *)loader;
 
-- (WebFrameLoadType)loadType;
-- (void)setLoadType:(WebFrameLoadType)type;
+- (FrameLoadType)loadType;
+- (void)setLoadType:(FrameLoadType)type;
 - (BOOL)delegateIsHandlingProvisionalLoadError;
 - (void)setDelegateIsHandlingProvisionalLoadError:(BOOL)is;
 
@@ -214,7 +225,7 @@ typedef enum {
 - (void)checkNavigationPolicyForRequest:(NSURLRequest *)request dataSource:(WebDataSource *)dataSource formState:(WebFormState *)formState andCall:(id)target withSelector:(SEL)selector;
 - (void)continueAfterWillSubmitForm:(WebPolicyAction)policy;
 - (void)continueLoadRequestAfterNavigationPolicy:(NSURLRequest *)request formState:(WebFormState *)formState;
-- (void)loadDataSource:(WebDataSource *)newDataSource withLoadType:(WebFrameLoadType)loadType formState:(WebFormState *)formState;
+- (void)loadDataSource:(WebDataSource *)newDataSource withLoadType:(FrameLoadType)loadType formState:(WebFormState *)formState;
 - (void)handleUnimplementablePolicyWithErrorCode:(int)code forURL:(NSURL *)URL;
 
 - (void)didFirstLayout;
@@ -222,7 +233,7 @@ typedef enum {
 
 - (void)clientRedirectCancelledOrFinished:(BOOL)cancelWithLoadInProgress;
 - (void)clientRedirectedTo:(NSURL *)URL delay:(NSTimeInterval)seconds fireDate:(NSDate *)date lockHistory:(BOOL)lockHistory isJavaScriptFormAction:(BOOL)isJavaScriptFormAction;
-- (void)loadURL:(NSURL *)URL referrer:(NSString *)referrer loadType:(WebFrameLoadType)loadType target:(NSString *)target triggeringEvent:(NSEvent *)event form:(DOMElement *)form formValues:(NSDictionary *)values;
+- (void)loadURL:(NSURL *)URL referrer:(NSString *)referrer loadType:(FrameLoadType)loadType target:(NSString *)target triggeringEvent:(NSEvent *)event form:(DOMElement *)form formValues:(NSDictionary *)values;
 - (void)commitProvisionalLoad:(NSDictionary *)pageCache;
 - (BOOL)isQuickRedirectComing;
 - (BOOL)shouldReloadForCurrent:(NSURL *)currentURL andDestination:(NSURL *)destinationURL;
index 8cf5d651b13da82a102be3849f46b1b9e1a51f19..06a1d2adb2b2e7a489569ae3f0c3a139d48ae18a 100644 (file)
@@ -35,6 +35,7 @@
 #import "WebFrameBridge.h"
 #import "WebFrameInternal.h"
 #import "WebFrameLoadDelegate.h"
+#import "WebFrameLoaderClient.h"
 #import "WebHistory.h"
 #import "WebIconDatabasePrivate.h"
 #import "WebKitErrorsPrivate.h"
@@ -645,20 +646,20 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
 }
 
 // main funnel for navigating via callback from WebCore (e.g., clicking a link, redirect)
-- (void)loadURL:(NSURL *)URL referrer:(NSString *)referrer loadType:(WebFrameLoadType)_loadType target:(NSString *)target triggeringEvent:(NSEvent *)event form:(DOMElement *)form formValues:(NSDictionary *)values
+- (void)loadURL:(NSURL *)URL referrer:(NSString *)referrer loadType:(FrameLoadType)_loadType target:(NSString *)target triggeringEvent:(NSEvent *)event form:(DOMElement *)form formValues:(NSDictionary *)values
 {
     BOOL isFormSubmission = (values != nil);
     
     NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:URL];
     [request setValue:[[client webView] userAgentForURL:[request URL]] forHTTPHeaderField:@"Referer"];
     [self _addExtraFieldsToRequest:request mainResource:YES alwaysFromRequest:(event != nil || isFormSubmission)];
-    if (_loadType == WebFrameLoadTypeReload) {
+    if (_loadType == FrameLoadTypeReload) {
         [request setCachePolicy:NSURLRequestReloadIgnoringCacheData];
     }
     
     // I believe this is never called with LoadSame.  If it is, we probably want to set the cache
     // policy of LoadFromOrigin, but I didn't test that.
-    ASSERT(_loadType != WebFrameLoadTypeSame);
+    ASSERT(_loadType != FrameLoadTypeSame);
     
     NSDictionary *action = [client _actionInformationForLoadType:_loadType isFormSubmission:isFormSubmission event:event originalURL:URL];
     WebFormState *formState = nil;
@@ -690,8 +691,8 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
     // exactly the same so pages with '#' links and DHTML side effects
     // work properly.
     if (!isFormSubmission
-        && _loadType != WebFrameLoadTypeReload
-        && _loadType != WebFrameLoadTypeSame
+        && _loadType != FrameLoadTypeReload
+        && _loadType != FrameLoadTypeSame
         && ![self shouldReloadForCurrent:URL andDestination:[[client _bridge] URL]]
         
         // We don't want to just scroll if a link from within a
@@ -723,7 +724,7 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
             // Example of this case are sites that reload the same URL with a different cookie
             // driving the generated content, or a master frame with links that drive a target
             // frame, where the user has clicked on the same link repeatedly.
-            [self setLoadType:WebFrameLoadTypeSame];
+            [self setLoadType:FrameLoadTypeSame];
         }            
     }
     
@@ -788,7 +789,7 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
 
 - (void)commitProvisionalLoad:(NSDictionary *)pageCache
 {
-    bool reload = loadType == WebFrameLoadTypeReload || loadType == WebFrameLoadTypeReloadAllowingStaleData;
+    bool reload = loadType == FrameLoadTypeReload || loadType == FrameLoadTypeReloadAllowingStaleData;
     
     WebDataSource *provisionalDataSource = [[self provisionalDataSource] retain];
     NSURLResponse *response = [provisionalDataSource response];
@@ -796,7 +797,7 @@ static CFAbsoluteTime _timeOfLastCompletedLoad;
     NSDictionary *headers = [response isKindOfClass:[NSHTTPURLResponse class]]
         ? [(NSHTTPURLResponse *)response allHeaderFields] : nil;
     
-    if (loadType != WebFrameLoadTypeReplace)
+    if (loadType != FrameLoadTypeReplace)
         [self closeOldDataSources];
     
     if (!pageCache)
@@ -1120,19 +1121,19 @@ static BOOL isCaseInsensitiveEqual(NSString *a, NSString *b)
     listener = nil;
 }
 
-static inline BOOL isBackForwardLoadType(WebFrameLoadType type)
+static inline BOOL isBackForwardLoadType(FrameLoadType type)
 {
     switch (type) {
-        case WebFrameLoadTypeStandard:
-        case WebFrameLoadTypeReload:
-        case WebFrameLoadTypeReloadAllowingStaleData:
-        case WebFrameLoadTypeSame:
-        case WebFrameLoadTypeInternal:
-        case WebFrameLoadTypeReplace:
+        case FrameLoadTypeStandard:
+        case FrameLoadTypeReload:
+        case FrameLoadTypeReloadAllowingStaleData:
+        case FrameLoadTypeSame:
+        case FrameLoadTypeInternal:
+        case FrameLoadTypeReplace:
             return false;
-        case WebFrameLoadTypeBack:
-        case WebFrameLoadTypeForward:
-        case WebFrameLoadTypeIndexedBackForward:
+        case FrameLoadTypeBack:
+        case FrameLoadTypeForward:
+        case FrameLoadTypeIndexedBackForward:
             return true;
     }
     ASSERT_NOT_REACHED();
@@ -1164,7 +1165,7 @@ static inline BOOL isBackForwardLoadType(WebFrameLoadType type)
 
 - (void)_loadRequest:(NSURLRequest *)request archive:(WebArchive *)archive
 {
-    WebFrameLoadType type;
+    FrameLoadType type;
     
     ASSERT(!policyDocumentLoader);
     policyDocumentLoader = [client _createDocumentLoaderWithRequest:request];
@@ -1174,9 +1175,9 @@ static inline BOOL isBackForwardLoadType(WebFrameLoadType type)
     [client _addExtraFieldsToRequest:r mainResource:YES alwaysFromRequest:NO];
     if ([client _shouldTreatURLAsSameAsCurrent:[request URL]]) {
         [r setCachePolicy:NSURLRequestReloadIgnoringCacheData];
-        type = WebFrameLoadTypeSame;
+        type = FrameLoadTypeSame;
     } else
-        type = WebFrameLoadTypeStandard;
+        type = FrameLoadTypeStandard;
     
     [policyDocumentLoader setOverrideEncoding:[[self documentLoader] overrideEncoding]];
     [newDataSource _addToUnarchiveState:archive];
@@ -1185,14 +1186,14 @@ static inline BOOL isBackForwardLoadType(WebFrameLoadType type)
     // visiting in the b/f list, we treat it as a reload so the b/f list 
     // is appropriately maintained.
     if ([self shouldReloadToHandleUnreachableURLFromRequest:request]) {
-        ASSERT(type == WebFrameLoadTypeStandard);
-        type = WebFrameLoadTypeReload;
+        ASSERT(type == FrameLoadTypeStandard);
+        type = FrameLoadTypeReload;
     }
     
     [self loadDataSource:newDataSource withLoadType:type formState:nil];
 }
 
-- (void)_loadRequest:(NSURLRequest *)request triggeringAction:(NSDictionary *)action loadType:(WebFrameLoadType)type formState:(WebFormState *)formState
+- (void)_loadRequest:(NSURLRequest *)request triggeringAction:(NSDictionary *)action loadType:(FrameLoadType)type formState:(WebFormState *)formState
 {
     ASSERT(!policyDocumentLoader);
     policyDocumentLoader = [client _createDocumentLoaderWithRequest:request];
@@ -1223,7 +1224,7 @@ static inline BOOL isBackForwardLoadType(WebFrameLoadType type)
     
     [policyDocumentLoader setOverrideEncoding:encoding];
 
-    [self loadDataSource:newDataSource withLoadType:WebFrameLoadTypeReloadAllowingStaleData formState:nil];
+    [self loadDataSource:newDataSource withLoadType:FrameLoadTypeReloadAllowingStaleData formState:nil];
 }
 
 - (void)reload
@@ -1259,7 +1260,7 @@ static inline BOOL isBackForwardLoadType(WebFrameLoadType type)
 
     [policyDocumentLoader setOverrideEncoding:[[ds _documentLoader] overrideEncoding]];
     
-    [self loadDataSource:newDataSource withLoadType:WebFrameLoadTypeReload formState:nil];
+    [self loadDataSource:newDataSource withLoadType:FrameLoadTypeReload formState:nil];
 }
 
 - (void)didReceiveServerRedirectForProvisionalLoadForFrame
@@ -1279,12 +1280,12 @@ static inline BOOL isBackForwardLoadType(WebFrameLoadType type)
 
 - (BOOL)isReplacing
 {
-    return loadType == WebFrameLoadTypeReplace;
+    return loadType == FrameLoadTypeReplace;
 }
 
 - (void)setReplacing
 {
-    loadType = WebFrameLoadTypeReplace;
+    loadType = FrameLoadTypeReplace;
 }
 
 - (void)revertToProvisionalWithDocumentLoader:(WebDocumentLoader *)loader
@@ -1353,12 +1354,12 @@ static inline BOOL isBackForwardLoadType(WebFrameLoadType type)
     }
 }
 
-- (WebFrameLoadType)loadType
+- (FrameLoadType)loadType
 {
     return loadType;
 }
 
-- (void)setLoadType:(WebFrameLoadType)type
+- (void)setLoadType:(FrameLoadType)type
 {
     loadType = type;
 }
@@ -1469,7 +1470,7 @@ static inline BOOL isBackForwardLoadType(WebFrameLoadType type)
     // treat it like a reload so it maintains the right state for b/f list.
     if ([request _webDataRequestUnreachableURL] != nil) {
         if (isBackForwardLoadType(policyLoadType))
-            policyLoadType = WebFrameLoadTypeReload;
+            policyLoadType = FrameLoadTypeReload;
         [target performSelector:selector withObject:request withObject:nil];
         return;
     }
@@ -1577,7 +1578,7 @@ static inline BOOL isBackForwardLoadType(WebFrameLoadType type)
         return;
     }
     
-    WebFrameLoadType type = policyLoadType;
+    FrameLoadType type = policyLoadType;
     WebDataSource *dataSource = [[self policyDataSource] retain];
     
     [self stopLoading];
@@ -1591,7 +1592,7 @@ static inline BOOL isBackForwardLoadType(WebFrameLoadType type)
     if (client == [[client webView] mainFrame])
         LOG(DocumentLoad, "loading %@", [[[self provisionalDataSource] request] URL]);
 
-    if (type == WebFrameLoadTypeForward || type == WebFrameLoadTypeBack || type == WebFrameLoadTypeIndexedBackForward) {
+    if (type == FrameLoadTypeForward || type == FrameLoadTypeBack || type == FrameLoadTypeIndexedBackForward) {
         if ([client _loadProvisionalItemFromPageCache])
             return;
     }
@@ -1607,7 +1608,7 @@ static inline BOOL isBackForwardLoadType(WebFrameLoadType type)
     }
 }
 
-- (void)loadDataSource:(WebDataSource *)newDataSource withLoadType:(WebFrameLoadType)type formState:(WebFormState *)formState
+- (void)loadDataSource:(WebDataSource *)newDataSource withLoadType:(FrameLoadType)type formState:(WebFormState *)formState
 {
     ASSERT([client webView] != nil);
 
@@ -1660,7 +1661,7 @@ static inline BOOL isBackForwardLoadType(WebFrameLoadType type)
 - (void)didFirstLayout
 {
     if ([[client webView] backForwardList]) {
-        if (loadType == WebFrameLoadTypeForward || loadType == WebFrameLoadTypeBack || loadType == WebFrameLoadTypeIndexedBackForward)
+        if (loadType == FrameLoadTypeForward || loadType == FrameLoadTypeBack || loadType == FrameLoadTypeIndexedBackForward)
             [client _restoreScrollPositionAndViewState];
     }
     
index 6663552866914ee182b7489ada73b9231e05f163..16adaa96f33cd850a6864336dbe825841b1f8ecc 100644 (file)
@@ -29,6 +29,7 @@
 
 #import <WebKit/WebPluginController.h>
 
+#import <WebKit/WebDocumentLoader.h>
 #import <WebKit/WebFrameBridge.h>
 #import <WebKit/WebFrameInternal.h>
 #import <WebKit/WebFrameView.h>
index 3a85eb86e207c4a55129b208d0435eb04bcf502c..8a392bb82c2588df002d1f87a8a0ac28037ebb2a 100644 (file)
@@ -34,6 +34,7 @@
 #import "WebBasePluginPackage.h"
 #import "WebDataSourceInternal.h"
 #import "WebDefaultUIDelegate.h"
+#import "WebDocumentLoader.h"
 #import "WebEditingDelegate.h"
 #import "WebFormDataStream.h"
 #import "WebFormDelegate.h"
index c2ad26e369dc5ce9565aa3266eff8fbbead759bf..b67304db1339f040512f875f39e5c69d657776ea 100644 (file)
@@ -105,7 +105,7 @@ NSString *WebPageCacheDocumentViewKey = @"WebPageCacheDocumentViewKey";
 
 @interface WebFrame (ForwardDecls)
 - (void)_loadHTMLString:(NSString *)string baseURL:(NSURL *)URL unreachableURL:(NSURL *)unreachableURL;
-- (NSDictionary *)_actionInformationForLoadType:(WebFrameLoadType)loadType isFormSubmission:(BOOL)isFormSubmission event:(NSEvent *)event originalURL:(NSURL *)URL;
+- (NSDictionary *)_actionInformationForLoadType:(FrameLoadType)loadType isFormSubmission:(BOOL)isFormSubmission event:(NSEvent *)event originalURL:(NSURL *)URL;
 
 - (void)_saveScrollPositionAndViewStateToItem:(WebHistoryItem *)item;
 
@@ -417,11 +417,11 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
         {
             [[[[self frameView] _scrollView] contentView] setCopiesOnScroll:YES];
 
-            WebFrameLoadType loadType = [[self _frameLoader] loadType];
-            if (loadType == WebFrameLoadTypeForward ||
-                loadType == WebFrameLoadTypeBack ||
-                loadType == WebFrameLoadTypeIndexedBackForward ||
-                (loadType == WebFrameLoadTypeReload && [[[self _frameLoader] provisionalDataSource] unreachableURL] != nil))
+            FrameLoadType loadType = [[self _frameLoader] loadType];
+            if (loadType == FrameLoadTypeForward ||
+                loadType == FrameLoadTypeBack ||
+                loadType == FrameLoadTypeIndexedBackForward ||
+                (loadType == FrameLoadTypeReload && [[[self _frameLoader] provisionalDataSource] unreachableURL] != nil))
             {
                 // Once committed, we want to use current item for saving DocState, and
                 // the provisional item for restoring state.
@@ -448,9 +448,9 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
             NSString *ptitle = [ds pageTitle];
 
             switch (loadType) {
-            case WebFrameLoadTypeForward:
-            case WebFrameLoadTypeBack:
-            case WebFrameLoadTypeIndexedBackForward:
+            case FrameLoadTypeForward:
+            case FrameLoadTypeBack:
+            case FrameLoadTypeIndexedBackForward:
                 if ([[self webView] backForwardList]) {
                     // Must grab the current scroll position before disturbing it
                     [self _saveScrollPositionAndViewStateToItem:_private->previousItem];
@@ -466,14 +466,14 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
                 }
                 break;
 
-            case WebFrameLoadTypeReload:
-            case WebFrameLoadTypeSame:
-            case WebFrameLoadTypeReplace:
+            case FrameLoadTypeReload:
+            case FrameLoadTypeSame:
+            case FrameLoadTypeReplace:
             {
                 WebHistoryItem *currItem = _private->currentItem;
                 LOG(PageCache, "Clearing back/forward cache, %@\n", [currItem URL]);
                 [currItem setHasPageCache:NO];
-                if (loadType == WebFrameLoadTypeReload) {
+                if (loadType == FrameLoadTypeReload) {
                     [self _saveScrollPositionAndViewStateToItem:currItem];
                 }
                 NSURLRequest *request = [ds request];
@@ -493,12 +493,12 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
                 break;
             }
 
-            // FIXME - just get rid of this case, and merge WebFrameLoadTypeReloadAllowingStaleData with the above case
-            case WebFrameLoadTypeReloadAllowingStaleData:
+            // FIXME - just get rid of this case, and merge FrameLoadTypeReloadAllowingStaleData with the above case
+            case FrameLoadTypeReloadAllowingStaleData:
                 [self _makeDocumentView];
                 break;
                 
-            case WebFrameLoadTypeStandard:
+            case FrameLoadTypeStandard:
                 if (![[ds _documentLoader] isClientRedirect]) {
                     // Add item to history and BF list
                     NSURL *URL = [ds _URLForHistory];
@@ -532,7 +532,7 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
                 [self _makeDocumentView];
                 break;
                 
-            case WebFrameLoadTypeInternal:
+            case FrameLoadTypeInternal:
                 // Add an item to the item tree for this frame
                 ASSERT(![[ds _documentLoader] isClientRedirect]);
                 WebFrame *parentFrame = [self parentFrame];
@@ -543,17 +543,17 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
                     if (parentItem)
                         [parentItem addChildItem:[self _createItem: YES]];
                 } else {
-                    // See 3556159.  It's not clear if it's valid to be in WebFrameLoadTypeOnLoadEvent
+                    // See 3556159.  It's not clear if it's valid to be in FrameLoadTypeOnLoadEvent
                     // for a top-level frame, but that was a likely explanation for those crashes,
                     // so let's guard against it.
-                    // ...and all WebFrameLoadTypeOnLoadEvent uses were folded to WebFrameLoadTypeInternal
+                    // ...and all FrameLoadTypeOnLoadEvent uses were folded to FrameLoadTypeInternal
                     LOG_ERROR("no parent frame in _transitionToCommitted:, loadType=%d", loadType);
                 }
                 [self _makeDocumentView];
                 break;
 
             // FIXME Remove this check when dummy ds is removed.  An exception should be thrown
-            // if we're in the WebFrameLoadTypeUninitialized state.
+            // if we're in the FrameLoadTypeUninitialized state.
             default:
                 ASSERT_NOT_REACHED();
             }
@@ -639,7 +639,7 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
 
 - (void)_provisionalLoadStarted
 {
-    WebFrameLoadType loadType = [[self _frameLoader] loadType];
+    FrameLoadType loadType = [[self _frameLoader] loadType];
     
     // FIXME: This is OK as long as no one resizes the window,
     // but in the case where someone does, it means garbage outside
@@ -656,9 +656,9 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
         && [_private->bridge canCachePage]
         && item
         && ![[self _frameLoader] isQuickRedirectComing]
-        && loadType != WebFrameLoadTypeReload 
-        && loadType != WebFrameLoadTypeReloadAllowingStaleData
-        && loadType != WebFrameLoadTypeSame
+        && loadType != FrameLoadTypeReload 
+        && loadType != FrameLoadTypeReloadAllowingStaleData
+        && loadType != FrameLoadTypeSame
         && ![[self dataSource] isLoading]
         && ![[[self _frameLoader] documentLoader] isStopping]) {
         if ([[[self dataSource] representation] isKindOfClass:[WebHTMLRepresentation class]]) {
@@ -684,7 +684,7 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
 // Called after we send an openURL:... down to WebCore.
 - (void)_opened
 {
-    if ([[self _frameLoader] loadType] == WebFrameLoadTypeStandard && [[[self dataSource] _documentLoader] isClientRedirect]) {
+    if ([[self _frameLoader] loadType] == FrameLoadTypeStandard && [[[self dataSource] _documentLoader] isClientRedirect]) {
         // Clear out form data so we don't try to restore it into the incoming page.  Must happen after
         // khtml has closed the URL and saved away the form state.
         WebHistoryItem *item = _private->currentItem;
@@ -812,18 +812,18 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
                 // that the user scroll point should override the anchor point.
                 if ([[self webView] backForwardList]) {
                     switch ([[self _frameLoader] loadType]) {
-                    case WebFrameLoadTypeForward:
-                    case WebFrameLoadTypeBack:
-                    case WebFrameLoadTypeIndexedBackForward:
-                    case WebFrameLoadTypeReload:
+                    case FrameLoadTypeForward:
+                    case FrameLoadTypeBack:
+                    case FrameLoadTypeIndexedBackForward:
+                    case FrameLoadTypeReload:
                         [self _restoreScrollPositionAndViewState];
                         break;
 
-                    case WebFrameLoadTypeStandard:
-                    case WebFrameLoadTypeInternal:
-                    case WebFrameLoadTypeReloadAllowingStaleData:
-                    case WebFrameLoadTypeSame:
-                    case WebFrameLoadTypeReplace:
+                    case FrameLoadTypeStandard:
+                    case FrameLoadTypeInternal:
+                    case FrameLoadTypeReloadAllowingStaleData:
+                    case FrameLoadTypeSame:
+                    case FrameLoadTypeReplace:
                         // Do nothing.
                         break;
 
@@ -936,7 +936,7 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
 }
 
 // loads content into this frame, as specified by item
-- (void)_loadItem:(WebHistoryItem *)item withLoadType:(WebFrameLoadType)loadType
+- (void)_loadItem:(WebHistoryItem *)item withLoadType:(FrameLoadType)loadType
 {
     NSURL *itemURL = [item URL];
     NSURL *itemOriginalURL = [NSURL _web_URLWithDataAsString:[item originalURLString]];
@@ -1037,23 +1037,23 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
                 }
             } else {
                 switch (loadType) {
-                    case WebFrameLoadTypeReload:
+                    case FrameLoadTypeReload:
                         [request setCachePolicy:NSURLRequestReloadIgnoringCacheData];
                         break;
-                    case WebFrameLoadTypeBack:
-                    case WebFrameLoadTypeForward:
-                    case WebFrameLoadTypeIndexedBackForward:
+                    case FrameLoadTypeBack:
+                    case FrameLoadTypeForward:
+                    case FrameLoadTypeIndexedBackForward:
                         if (![[itemURL scheme] isEqual:@"https"]) {
                             [request setCachePolicy:NSURLRequestReturnCacheDataElseLoad];
                         }
                         break;
-                    case WebFrameLoadTypeStandard:
-                    case WebFrameLoadTypeInternal:
+                    case FrameLoadTypeStandard:
+                    case FrameLoadTypeInternal:
                         // no-op: leave as protocol default
                         // FIXME:  I wonder if we ever hit this case
                         break;
-                    case WebFrameLoadTypeSame:
-                    case WebFrameLoadTypeReloadAllowingStaleData:
+                    case FrameLoadTypeSame:
+                    case FrameLoadTypeReloadAllowingStaleData:
                     default:
                         ASSERT_NOT_REACHED();
                 }
@@ -1071,7 +1071,7 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
 // tracking whether each frame already has the content the item requests.  If there is
 // a match (by URL), we just restore scroll position and recurse.  Otherwise we must
 // reload that frame, and all its kids.
-- (void)_recursiveGoToItem:(WebHistoryItem *)item fromItem:(WebHistoryItem *)fromItem withLoadType:(WebFrameLoadType)type
+- (void)_recursiveGoToItem:(WebHistoryItem *)item fromItem:(WebHistoryItem *)fromItem withLoadType:(FrameLoadType)type
 {
     NSURL *itemURL = [item URL];
     NSURL *currentURL = [[[self dataSource] request] URL];
@@ -1121,7 +1121,7 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
 
 // Main funnel for navigating to a previous location (back/forward, non-search snap-back)
 // This includes recursion to handle loading into framesets properly
-- (void)_goToItem:(WebHistoryItem *)item withLoadType:(WebFrameLoadType)type
+- (void)_goToItem:(WebHistoryItem *)item withLoadType:(FrameLoadType)type
 {
     ASSERT(![self parentFrame]);
     // shouldGoToHistoryItem is a private delegate method. This is needed to fix:
@@ -1182,17 +1182,17 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
     }
 }
 
--(NSDictionary *)_actionInformationForLoadType:(WebFrameLoadType)loadType isFormSubmission:(BOOL)isFormSubmission event:(NSEvent *)event originalURL:(NSURL *)URL
+-(NSDictionary *)_actionInformationForLoadType:(FrameLoadType)loadType isFormSubmission:(BOOL)isFormSubmission event:(NSEvent *)event originalURL:(NSURL *)URL
 {
     WebNavigationType navType;
     if (isFormSubmission) {
         navType = WebNavigationTypeFormSubmitted;
     } else if (event == nil) {
-        if (loadType == WebFrameLoadTypeReload) {
+        if (loadType == FrameLoadTypeReload) {
             navType = WebNavigationTypeReload;
-        } else if (loadType == WebFrameLoadTypeForward
-                   || loadType == WebFrameLoadTypeBack
-                   || loadType == WebFrameLoadTypeIndexedBackForward) {
+        } else if (loadType == FrameLoadTypeForward
+                   || loadType == FrameLoadTypeBack
+                   || loadType == FrameLoadTypeIndexedBackForward) {
             navType = WebNavigationTypeBackForward;
         } else {
             navType = WebNavigationTypeOther;
@@ -1231,7 +1231,7 @@ static inline WebFrame *Frame(WebCoreFrameBridge *bridge)
     [[webView _UIDelegateForwarder] webViewShow:webView];
 
     [[frame _bridge] setOpener:[self _bridge]];
-    [[frame _frameLoader] _loadRequest:request triggeringAction:nil loadType:WebFrameLoadTypeStandard formState:formState];
+    [[frame _frameLoader] _loadRequest:request triggeringAction:nil loadType:FrameLoadTypeStandard formState:formState];
 
     [frame release];
 
@@ -1243,19 +1243,19 @@ exit:
 {
     WebHistoryItem *parentItem = _private->currentItem;
     NSArray *childItems = [parentItem children];
-    WebFrameLoadType loadType = [[self _frameLoader] loadType];
-    WebFrameLoadType childLoadType = WebFrameLoadTypeInternal;
+    FrameLoadType loadType = [[self _frameLoader] loadType];
+    FrameLoadType childLoadType = FrameLoadTypeInternal;
     WebHistoryItem *childItem = nil;
 
     // If we're moving in the backforward list, we might want to replace the content
     // of this child frame with whatever was there at that point.
     // Reload will maintain the frame contents, LoadSame will not.
     if (childItems &&
-        (loadType == WebFrameLoadTypeForward
-         || loadType == WebFrameLoadTypeBack
-         || loadType == WebFrameLoadTypeIndexedBackForward
-         || loadType == WebFrameLoadTypeReload
-         || loadType == WebFrameLoadTypeReloadAllowingStaleData))
+        (loadType == FrameLoadTypeForward
+         || loadType == FrameLoadTypeBack
+         || loadType == FrameLoadTypeIndexedBackForward
+         || loadType == FrameLoadTypeReload
+         || loadType == FrameLoadTypeReloadAllowingStaleData))
     {
         childItem = [parentItem childItemWithName:[childFrame name]];
         if (childItem) {
@@ -1266,9 +1266,9 @@ exit:
             // These behaviors implied by these loadTypes should apply to the child frames
             childLoadType = loadType;
 
-            if (loadType == WebFrameLoadTypeForward
-                || loadType == WebFrameLoadTypeBack
-                || loadType == WebFrameLoadTypeIndexedBackForward)
+            if (loadType == FrameLoadTypeForward
+                || loadType == FrameLoadTypeBack
+                || loadType == FrameLoadTypeIndexedBackForward)
             {
                 // For back/forward, remember this item so we can traverse any child items as child frames load
                 [childFrame->_private setProvisionalItem:childItem];
@@ -1302,7 +1302,7 @@ exit:
     webSetHTTPBody(request, postData);
     [request _web_setHTTPContentType:contentType];
 
-    NSDictionary *action = [self _actionInformationForLoadType:WebFrameLoadTypeStandard isFormSubmission:YES event:event originalURL:URL];
+    NSDictionary *action = [self _actionInformationForLoadType:FrameLoadTypeStandard isFormSubmission:YES event:event originalURL:URL];
     WebFormState *formState = nil;
     if (form && values) {
         formState = [[WebFormState alloc] initWithForm:form values:values sourceFrame:self];
@@ -1312,7 +1312,7 @@ exit:
         WebFrame *targetFrame = [self findFrameNamed:target];
 
         if (targetFrame != nil) {
-            [[targetFrame _frameLoader] _loadRequest:request triggeringAction:action loadType:WebFrameLoadTypeStandard formState:formState];
+            [[targetFrame _frameLoader] _loadRequest:request triggeringAction:action loadType:FrameLoadTypeStandard formState:formState];
         } else {
             [[self _frameLoader] checkNewWindowPolicyForRequest:request action:action frameName:target formState:formState andCall:self
                 withSelector:@selector(_continueLoadRequestAfterNewWindowPolicy:frameName:formState:)];
@@ -1322,7 +1322,7 @@ exit:
         return;
     }
 
-    [[self _frameLoader] _loadRequest:request triggeringAction:action loadType:WebFrameLoadTypeStandard formState:formState];
+    [[self _frameLoader] _loadRequest:request triggeringAction:action loadType:FrameLoadTypeStandard formState:formState];
 
     [request release];
     [formState release];
@@ -1387,10 +1387,10 @@ exit:
 // Return the item that we would reset to, so we can decide later whether to actually reset.
 - (WebHistoryItem *)_currentBackForwardListItemToResetTo
 {
-    WebFrameLoadType loadType = [[self _frameLoader] loadType];
-    if ((loadType == WebFrameLoadTypeForward
-         || loadType == WebFrameLoadTypeBack
-         || loadType == WebFrameLoadTypeIndexedBackForward)
+    FrameLoadType loadType = [[self _frameLoader] loadType];
+    if ((loadType == FrameLoadTypeForward
+         || loadType == FrameLoadTypeBack
+         || loadType == FrameLoadTypeIndexedBackForward)
         && self == [[self webView] mainFrame]) {
         return _private->currentItem;
     }
@@ -1416,17 +1416,17 @@ exit:
 - (WebHistoryItem *)_itemForRestoringDocState
 {
     switch ([[self _frameLoader] loadType]) {
-        case WebFrameLoadTypeReload:
-        case WebFrameLoadTypeReloadAllowingStaleData:
-        case WebFrameLoadTypeSame:
-        case WebFrameLoadTypeReplace:
+        case FrameLoadTypeReload:
+        case FrameLoadTypeReloadAllowingStaleData:
+        case FrameLoadTypeSame:
+        case FrameLoadTypeReplace:
             // Don't restore any form state on reload or loadSame
             return nil;
-        case WebFrameLoadTypeBack:
-        case WebFrameLoadTypeForward:
-        case WebFrameLoadTypeIndexedBackForward:
-        case WebFrameLoadTypeInternal:
-        case WebFrameLoadTypeStandard:
+        case FrameLoadTypeBack:
+        case FrameLoadTypeForward:
+        case FrameLoadTypeIndexedBackForward:
+        case FrameLoadTypeInternal:
+        case FrameLoadTypeStandard:
             return _private->currentItem;
     }
     ASSERT_NOT_REACHED();
@@ -1800,7 +1800,7 @@ exit:
 {
     [request _web_setHTTPUserAgent:[[self webView] userAgentForURL:[request URL]]];
     
-    if ([[self _frameLoader] loadType] == WebFrameLoadTypeReload)
+    if ([[self _frameLoader] loadType] == FrameLoadTypeReload)
         [request setValue:@"max-age=0" forHTTPHeaderField:@"Cache-Control"];
     
     // Don't set the cookie policy URL if it's already been set.
@@ -1955,7 +1955,7 @@ exit:
 
 - (WebFrameLoadType)_loadType
 {
-    return [[self _frameLoader] loadType];
+    return (WebFrameLoadType)[[self _frameLoader] loadType];
 }
 
 @end
@@ -2070,7 +2070,7 @@ exit:
 {
     // FIXME: is this the right place to reset loadType? Perhaps this should be done
     // after loading is finished or aborted.
-    [[self _frameLoader] setLoadType:WebFrameLoadTypeStandard];
+    [[self _frameLoader] setLoadType:FrameLoadTypeStandard];
     [[self _frameLoader] _loadRequest:request archive:nil];
 }
 
index d622241df3f0ffa80aa99c373b538cedd01bc5ee..3b93d525bef65fb22605984e65de9c7705c5cf14 100644 (file)
 #import "WebFrameLoaderClient.h"
 #import "WebPolicyDelegatePrivate.h"
 
+#import "WebFrameLoader.h"
+
 @class WebDocumentLoader;
 @class WebInspector;
-@class WebFrameLoader;
 @class WebFrameView;
 @class WebFrameBridge;
 @class WebFormState;
 - (void)_checkLoadComplete;
 - (WebFrameBridge *)_bridge;
 
-- (void)_goToItem:(WebHistoryItem *)item withLoadType:(WebFrameLoadType)type;
+- (void)_goToItem:(WebHistoryItem *)item withLoadType:(FrameLoadType)type;
 - (void)_loadURL:(NSURL *)URL referrer:(NSString *)referrer intoChild:(WebFrame *)childFrame;
 - (void)_postWithURL:(NSURL *)URL referrer:(NSString *)referrer target:(NSString *)target data:(NSArray *)postData contentType:(NSString *)contentType triggeringEvent:(NSEvent *)event form:(DOMElement *)form formValues:(NSDictionary *)values;
 
index 94edb8cdde44341e3f4f598c9be8766d6bd78f80..5df00a1fa840d1aa0da08e6cec3da9ee4f5f60dd 100644 (file)
@@ -44,6 +44,7 @@
 #import "WebDefaultUIDelegate.h"
 #import "WebDocument.h"
 #import "WebDocumentInternal.h"
+#import "WebDocumentLoader.h"
 #import "WebDownload.h"
 #import "WebDownloadInternal.h"
 #import "WebDynamicScrollBarsView.h"