#ifndef FrameLoader_h
#define FrameLoader_h
#include "CachePolicy.h"
#include "FrameLoaderStateMachine.h"
#include "FrameLoaderTypes.h"
#include "IconURL.h"
#include "LayoutMilestones.h"
#include "MixedContentChecker.h"
#include "ResourceHandleTypes.h"
#include "ResourceLoadNotifier.h"
#include "SecurityContext.h"
#include "Timer.h"
#include <wtf/Forward.h>
#include <wtf/HashSet.h>
namespace WebCore {
class Archive;
class CachedFrameBase;
class CachedPage;
class CachedResource;
class Chrome;
class DOMWrapperWorld;
class Document;
class DocumentLoader;
class Event;
class FormState;
class FormSubmission;
class FrameLoaderClient;
class FrameNetworkingContext;
class HistoryController;
class HistoryItem;
class IconController;
class NavigationAction;
class NetworkingContext;
class Page;
class PageActivityAssertionToken;
class PolicyChecker;
class ResourceError;
class ResourceRequest;
class ResourceResponse;
class SecurityOrigin;
class SerializedScriptValue;
class StringWithDirection;
class SubframeLoader;
class SubstituteData;
struct FrameLoadRequest;
struct WindowFeatures;
bool isBackForwardLoadType(FrameLoadType);
class FrameLoader {
WTF_MAKE_NONCOPYABLE(FrameLoader);
public:
FrameLoader(Frame&, FrameLoaderClient&);
~FrameLoader();
void init();
#if PLATFORM(IOS)
void initForSynthesizedDocument(const URL&);
#endif
Frame& frame() const { return m_frame; }
PolicyChecker& policyChecker() const { return *m_policyChecker; }
HistoryController& history() const { return *m_history; }
ResourceLoadNotifier& notifier() const { return m_notifier; }
SubframeLoader& subframeLoader() const { return *m_subframeLoader; }
IconController& icon() const { return *m_icon; }
MixedContentChecker& mixedContentChecker() const { return m_mixedContentChecker; }
void prepareForHistoryNavigation();
void setupForReplace();
void loadURLIntoChildFrame(const URL&, const String& referer, Frame*);
void loadFrameRequest(const FrameLoadRequest&, LockHistory, LockBackForwardList, PassRefPtr<Event>, PassRefPtr<FormState>, ShouldSendReferrer, AllowNavigationToInvalidURL, NewFrameOpenerPolicy);
void load(const FrameLoadRequest&);
#if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
void loadArchive(PassRefPtr<Archive>);
#endif
unsigned long loadResourceSynchronously(const ResourceRequest&, StoredCredentials, ClientCredentialPolicy, ResourceError&, ResourceResponse&, Vector<char>& data);
void changeLocation(SecurityOrigin*, const URL&, const String& referrer, LockHistory = LockHistory::Yes,
LockBackForwardList = LockBackForwardList::Yes, bool refresh = false, AllowNavigationToInvalidURL = AllowNavigationToInvalidURL::Yes);
void urlSelected(const URL&, const String& target, PassRefPtr<Event>, LockHistory, LockBackForwardList, ShouldSendReferrer);
void submitForm(PassRefPtr<FormSubmission>);
void reload(bool endToEndReload = false);
void reloadWithOverrideEncoding(const String& overrideEncoding);
void open(CachedFrameBase&);
void loadItem(HistoryItem*, FrameLoadType);
HistoryItem* requestedHistoryItem() const { return m_requestedHistoryItem.get(); }
void retryAfterFailedCacheOnlyMainResourceLoad();
static void reportLocalLoadFailed(Frame*, const String& url);
void stopAllLoaders(ClearProvisionalItemPolicy = ShouldClearProvisionalItem);
void stopForUserCancel(bool deferCheckLoadComplete = false);
void stop();
void stopLoading(UnloadEventPolicy);
bool closeURL();
void cancelAndClear();
void clear(Document* newDocument, bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true);
bool isLoading() const;
bool frameHasLoaded() const;
int numPendingOrLoadingRequests(bool recurse) const;
String referrer() const;
String outgoingReferrer() const;
String outgoingOrigin() const;
DocumentLoader* activeDocumentLoader() const;
DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
FrameState state() const { return m_state; }
#if PLATFORM(IOS)
RetainPtr<CFDictionaryRef> connectionProperties(ResourceLoader*);
#endif
const ResourceRequest& originalRequest() const;
const ResourceRequest& initialRequest() const;
void receivedMainResourceError(const ResourceError&);
bool willLoadMediaElementURL(URL&);
void handleFallbackContent();
ResourceError cancelledError(const ResourceRequest&) const;
bool isHostedByObjectElement() const;
bool isReplacing() const;
void setReplacing();
bool subframeIsLoading() const;
void willChangeTitle(DocumentLoader*);
void didChangeTitle(DocumentLoader*);
void didChangeIcons(IconType);
bool shouldTreatURLAsSrcdocDocument(const URL&) const;
FrameLoadType loadType() const;
CachePolicy subresourceCachePolicy() const;
void didLayout(LayoutMilestones);
void didFirstLayout();
void loadedResourceFromMemoryCache(CachedResource*, ResourceRequest& newRequest);
void tellClientAboutPastMemoryCacheLoads();
void checkLoadComplete();
void detachFromParent();
void detachViewsAndDocumentLoader();
void addExtraFieldsToSubresourceRequest(ResourceRequest&);
void addExtraFieldsToMainResourceRequest(ResourceRequest&);
static void addHTTPOriginIfNeeded(ResourceRequest&, const String& origin);
FrameLoaderClient& client() const { return m_client; }
void setDefersLoading(bool);
void didExplicitOpen();
void didBeginDocument(bool dispatchWindowObjectAvailable);
void receivedFirstData();
void handledOnloadEvents();
String userAgent(const URL&) const;
void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld&);
void dispatchDidClearWindowObjectsInAllWorlds();
void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
SandboxFlags effectiveSandboxFlags() const;
bool checkIfFormActionAllowedByCSP(const URL&) const;
Frame* opener();
void setOpener(Frame*);
void resetMultipleFormSubmissionProtection();
void checkCallImplicitClose();
void frameDetached();
void setOutgoingReferrer(const URL&);
void loadDone();
void finishedParsing();
void checkCompleted();
bool isComplete() const;
void commitProvisionalLoad();
void setLoadsSynchronously(bool loadsSynchronously) { m_loadsSynchronously = loadsSynchronously; }
bool loadsSynchronously() const { return m_loadsSynchronously; }
FrameLoaderStateMachine& stateMachine() { return m_stateMachine; }
Frame* findFrameForNavigation(const AtomicString& name, Document* activeDocument = 0);
void applyUserAgent(ResourceRequest&);
bool shouldInterruptLoadForXFrameOptions(const String&, const URL&, unsigned long requestIdentifier);
void completed();
bool allAncestorsAreComplete() const; void clientRedirected(const URL&, double delay, double fireDate, LockBackForwardList);
void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
void continueLoadAfterWillSubmitForm();
void setOriginalURLForDownloadRequest(ResourceRequest&);
static ObjectContentType defaultObjectContentType(const URL&, const String& mimeType, bool shouldPreferPlugInsForImages);
bool quickRedirectComing() const { return m_quickRedirectComing; }
bool shouldClose();
void started();
enum PageDismissalType {
NoDismissal = 0,
BeforeUnloadDismissal = 1,
PageHideDismissal = 2,
UnloadDismissal = 3
};
PageDismissalType pageDismissalEventBeingDispatched() const { return m_pageDismissalEventBeingDispatched; }
NetworkingContext* networkingContext() const;
void loadProgressingStatusChanged();
const URL& previousURL() const { return m_previousURL; }
void forcePageTransitionIfNeeded();
private:
enum FormSubmissionCacheLoadPolicy {
MayAttemptCacheOnlyLoadForFormSubmissionItem,
MayNotAttemptCacheOnlyLoadForFormSubmissionItem
};
bool allChildrenAreComplete() const;
void checkTimerFired(Timer&);
void loadSameDocumentItem(HistoryItem*);
void loadDifferentDocumentItem(HistoryItem*, FrameLoadType, FormSubmissionCacheLoadPolicy);
void loadProvisionalItemFromCachedPage();
void updateFirstPartyForCookies();
void setFirstPartyForCookies(const URL&);
void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType, bool isMainResource);
void clearProvisionalLoad();
void transitionToCommitted(CachedPage*);
void frameLoadCompleted();
SubstituteData defaultSubstituteDataForURL(const URL&);
bool handleBeforeUnloadEvent(Chrome&, FrameLoader* frameLoaderBeingNavigated);
void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue, AllowNavigationToInvalidURL);
void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue, AllowNavigationToInvalidURL, NewFrameOpenerPolicy);
void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
bool shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType, const URL&);
void scrollToFragmentWithParentBoundary(const URL&);
void checkLoadCompleteForThisFrame();
void setDocumentLoader(DocumentLoader*);
void setPolicyDocumentLoader(DocumentLoader*);
void setProvisionalDocumentLoader(DocumentLoader*);
void setState(FrameState);
void closeOldDataSources();
void prepareForCachedPageRestore();
bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
void dispatchDidCommitLoad();
void urlSelected(const FrameLoadRequest&, PassRefPtr<Event>, LockHistory, LockBackForwardList, ShouldSendReferrer, ShouldReplaceDocumentIfJavaScriptURL, AllowNavigationToInvalidURL);
void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>, AllowNavigationToInvalidURL); void load(DocumentLoader*);
void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&, LockHistory, FrameLoadType, PassRefPtr<FormState>, AllowNavigationToInvalidURL);
void loadPostRequest(const ResourceRequest&, const String& referrer, const String& frameName, LockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>, AllowNavigationToInvalidURL, NewFrameOpenerPolicy);
void loadURL(const URL&, const String& referrer, const String& frameName, LockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>, AllowNavigationToInvalidURL, NewFrameOpenerPolicy);
bool shouldReload(const URL& currentURL, const URL& destinationURL);
void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
void detachChildren();
void closeAndRemoveChild(Frame*);
void loadInSameDocument(const URL&, PassRefPtr<SerializedScriptValue> stateObject, bool isNewNavigation);
void prepareForLoadStart();
void provisionalLoadStarted();
void willTransitionToCommitted();
bool didOpenURL();
void scheduleCheckCompleted();
void scheduleCheckLoadComplete();
void startCheckCompleteTimer();
bool shouldTreatURLAsSameAsCurrent(const URL&) const;
void dispatchGlobalObjectAvailableInAllWorlds();
Frame& m_frame;
FrameLoaderClient& m_client;
const std::unique_ptr<PolicyChecker> m_policyChecker;
const std::unique_ptr<HistoryController> m_history;
mutable ResourceLoadNotifier m_notifier;
const std::unique_ptr<SubframeLoader> m_subframeLoader;
mutable FrameLoaderStateMachine m_stateMachine;
const std::unique_ptr<IconController> m_icon;
mutable MixedContentChecker m_mixedContentChecker;
class FrameProgressTracker;
std::unique_ptr<FrameProgressTracker> m_progressTracker;
FrameState m_state;
FrameLoadType m_loadType;
RefPtr<DocumentLoader> m_documentLoader;
RefPtr<DocumentLoader> m_provisionalDocumentLoader;
RefPtr<DocumentLoader> m_policyDocumentLoader;
bool m_delegateIsHandlingProvisionalLoadError;
bool m_quickRedirectComing;
bool m_sentRedirectNotification;
bool m_inStopAllLoaders;
String m_outgoingReferrer;
bool m_isExecutingJavaScriptFormAction;
bool m_didCallImplicitClose;
bool m_wasUnloadEventEmitted;
PageDismissalType m_pageDismissalEventBeingDispatched;
bool m_isComplete;
RefPtr<SerializedScriptValue> m_pendingStateObject;
bool m_needsClear;
URL m_submittedFormURL;
Timer m_checkTimer;
bool m_shouldCallCheckCompleted;
bool m_shouldCallCheckLoadComplete;
Frame* m_opener;
HashSet<Frame*> m_openedFrames;
bool m_loadingFromCachedPage;
bool m_currentNavigationHasShownBeforeUnloadConfirmPanel;
bool m_loadsSynchronously;
SandboxFlags m_forcedSandboxFlags;
RefPtr<FrameNetworkingContext> m_networkingContext;
URL m_previousURL;
RefPtr<HistoryItem> m_requestedHistoryItem;
std::unique_ptr<PageActivityAssertionToken> m_activityAssertion;
};
PassRefPtr<Frame> createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created);
}
#endif // FrameLoader_h