@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 / blobdiff