#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,
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
NSMutableDictionary *pendingArchivedResources;
- WebFrameLoadType loadType;
+ FrameLoadType loadType;
// state we'll need to continue after waiting for the policy delegate's decision
NSURLRequest *policyRequest;
id policyTarget;
SEL policySelector;
WebFormState *policyFormState;
- WebFrameLoadType policyLoadType;
+ FrameLoadType policyLoadType;
BOOL delegateIsHandlingProvisionalLoadError;
BOOL delegateIsDecidingNavigationPolicy;
- (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;
- (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;
- (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;
- (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;
#import "WebFrameBridge.h"
#import "WebFrameInternal.h"
#import "WebFrameLoadDelegate.h"
+#import "WebFrameLoaderClient.h"
#import "WebHistory.h"
#import "WebIconDatabasePrivate.h"
#import "WebKitErrorsPrivate.h"
}
// 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;
// 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
// 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];
}
}
- (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];
NSDictionary *headers = [response isKindOfClass:[NSHTTPURLResponse class]]
? [(NSHTTPURLResponse *)response allHeaderFields] : nil;
- if (loadType != WebFrameLoadTypeReplace)
+ if (loadType != FrameLoadTypeReplace)
[self closeOldDataSources];
if (!pageCache)
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();
- (void)_loadRequest:(NSURLRequest *)request archive:(WebArchive *)archive
{
- WebFrameLoadType type;
+ FrameLoadType type;
ASSERT(!policyDocumentLoader);
policyDocumentLoader = [client _createDocumentLoaderWithRequest:request];
[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];
// 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];
[policyDocumentLoader setOverrideEncoding:encoding];
- [self loadDataSource:newDataSource withLoadType:WebFrameLoadTypeReloadAllowingStaleData formState:nil];
+ [self loadDataSource:newDataSource withLoadType:FrameLoadTypeReloadAllowingStaleData formState:nil];
}
- (void)reload
[policyDocumentLoader setOverrideEncoding:[[ds _documentLoader] overrideEncoding]];
- [self loadDataSource:newDataSource withLoadType:WebFrameLoadTypeReload formState:nil];
+ [self loadDataSource:newDataSource withLoadType:FrameLoadTypeReload formState:nil];
}
- (void)didReceiveServerRedirectForProvisionalLoadForFrame
- (BOOL)isReplacing
{
- return loadType == WebFrameLoadTypeReplace;
+ return loadType == FrameLoadTypeReplace;
}
- (void)setReplacing
{
- loadType = WebFrameLoadTypeReplace;
+ loadType = FrameLoadTypeReplace;
}
- (void)revertToProvisionalWithDocumentLoader:(WebDocumentLoader *)loader
}
}
-- (WebFrameLoadType)loadType
+- (FrameLoadType)loadType
{
return loadType;
}
-- (void)setLoadType:(WebFrameLoadType)type
+- (void)setLoadType:(FrameLoadType)type
{
loadType = 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;
}
return;
}
- WebFrameLoadType type = policyLoadType;
+ FrameLoadType type = policyLoadType;
WebDataSource *dataSource = [[self policyDataSource] retain];
[self stopLoading];
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;
}
}
}
-- (void)loadDataSource:(WebDataSource *)newDataSource withLoadType:(WebFrameLoadType)type formState:(WebFormState *)formState
+- (void)loadDataSource:(WebDataSource *)newDataSource withLoadType:(FrameLoadType)type formState:(WebFormState *)formState
{
ASSERT([client webView] != nil);
- (void)didFirstLayout
{
if ([[client webView] backForwardList]) {
- if (loadType == WebFrameLoadTypeForward || loadType == WebFrameLoadTypeBack || loadType == WebFrameLoadTypeIndexedBackForward)
+ if (loadType == FrameLoadTypeForward || loadType == FrameLoadTypeBack || loadType == FrameLoadTypeIndexedBackForward)
[client _restoreScrollPositionAndViewState];
}
@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;
{
[[[[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.
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];
}
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];
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];
[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];
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();
}
- (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
&& [_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]]) {
// 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;
// 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;
}
// 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]];
}
} 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();
}
// 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];
// 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:
}
}
--(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;
[[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];
{
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) {
// 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];
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];
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:)];
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];
// 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;
}
- (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();
{
[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.
- (WebFrameLoadType)_loadType
{
- return [[self _frameLoader] loadType];
+ return (WebFrameLoadType)[[self _frameLoader] loadType];
}
@end
{
// 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];
}
git://git.webkit.org / WebKit-https.git / commitdiff