#ifndef FrameLoader_h
#define FrameLoader_h
#include "CachePolicy.h"
#include "DocumentWriter.h"
#include "FrameLoaderTypes.h"
#include "HistoryController.h"
#include "PolicyCallback.h"
#include "PolicyChecker.h"
#include "RedirectScheduler.h"
#include "ResourceLoadNotifier.h"
#include "ResourceRequest.h"
#include "ThreadableLoader.h"
#include "Timer.h"
#include <wtf/Forward.h>
namespace WebCore {
class Archive;
class AuthenticationChallenge;
class CachedFrameBase;
class CachedPage;
class CachedResource;
class DOMWrapperWorld;
class Document;
class DocumentLoader;
class Event;
class FormData;
class FormState;
class Frame;
class FrameLoaderClient;
class HistoryItem;
class HTMLAppletElement;
class HTMLFormElement;
class HTMLFrameOwnerElement;
class IconLoader;
class IntSize;
class NavigationAction;
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
class Node;
#endif
class ProtectionSpace;
class RenderEmbeddedObject;
class ResourceError;
class ResourceLoader;
class ResourceResponse;
class ScriptSourceCode;
class ScriptString;
class ScriptValue;
class SecurityOrigin;
class SerializedScriptValue;
class SharedBuffer;
class SubstituteData;
class TextResourceDecoder;
class Widget;
struct FrameLoadRequest;
struct WindowFeatures;
bool isBackForwardLoadType(FrameLoadType);
class FrameLoader : public Noncopyable {
public:
FrameLoader(Frame*, FrameLoaderClient*);
~FrameLoader();
void init();
Frame* frame() const { return m_frame; }
PolicyChecker* policyChecker() const { return &m_policyChecker; }
HistoryController* history() const { return &m_history; }
ResourceLoadNotifier* notifier() const { return &m_notifer; }
DocumentWriter* writer() const { return &m_writer; }
void prepareForLoadStart();
void setupForReplace();
void setupForReplaceByMIMEType(const String& newMIMEType);
void loadURLIntoChildFrame(const KURL&, const String& referer, Frame*);
void loadFrameRequest(const FrameLoadRequest&, bool lockHistory, bool lockBackForwardList, PassRefPtr<Event>, PassRefPtr<FormState>, ReferrerPolicy);
void load(const ResourceRequest&, bool lockHistory); void load(const ResourceRequest&, const SubstituteData&, bool lockHistory); void load(const ResourceRequest&, const String& frameName, bool lockHistory);
void loadArchive(PassRefPtr<Archive>);
static void reportLocalLoadFailed(Frame*, const String& url);
Frame* createWindow(FrameLoader* frameLoaderForFrameLookup, const FrameLoadRequest&, const WindowFeatures&, bool& created);
unsigned long loadResourceSynchronously(const ResourceRequest&, StoredCredentials, ResourceError&, ResourceResponse&, Vector<char>& data);
bool canHandleRequest(const ResourceRequest&);
void stopAllLoaders(DatabasePolicy = DatabasePolicyStop);
void stopForUserCancel(bool deferCheckLoadComplete = false);
bool isLoadingMainResource() const { return m_isLoadingMainResource; }
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; }
static double timeOfLastCompletedLoad();
bool shouldUseCredentialStorage(ResourceLoader*);
#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
bool canAuthenticateAgainstProtectionSpace(ResourceLoader* loader, const ProtectionSpace& protectionSpace);
#endif
const ResourceRequest& originalRequest() const;
const ResourceRequest& initialRequest() const;
void receivedMainResourceError(const ResourceError&, bool isComplete);
void receivedData(const char*, int);
bool willLoadMediaElementURL(KURL&);
void handleFallbackContent();
bool isStopping() const;
void finishedLoading();
ResourceError cancelledError(const ResourceRequest&) const;
ResourceError fileDoesNotExistError(const ResourceResponse&) const;
ResourceError blockedError(const ResourceRequest&) const;
ResourceError cannotShowURLError(const ResourceRequest&) const;
ResourceError interruptionForPolicyChangeError(const ResourceRequest&);
bool isHostedByObjectElement() const;
bool isLoadingMainFrame() const;
bool canShowMIMEType(const String& MIMEType) const;
bool representationExistsForURLScheme(const String& URLScheme);
String generatedMIMETypeForURLScheme(const String& URLScheme);
void reload(bool endToEndReload = false);
void reloadWithOverrideEncoding(const String& overrideEncoding);
void didReceiveServerRedirectForProvisionalLoadForFrame();
void finishedLoadingDocument(DocumentLoader*);
void committedLoad(DocumentLoader*, const char*, int);
bool isReplacing() const;
void setReplacing();
void revertToProvisional(DocumentLoader*);
void setMainDocumentError(DocumentLoader*, const ResourceError&);
void mainReceivedCompleteError(DocumentLoader*, const ResourceError&);
bool subframeIsLoading() const;
void willChangeTitle(DocumentLoader*);
void didChangeTitle(DocumentLoader*);
void didChangeIcons(DocumentLoader*);
FrameLoadType loadType() const;
CachePolicy subresourceCachePolicy() const;
void didFirstLayout();
bool firstLayoutDone() const;
void didFirstVisuallyNonEmptyLayout();
void loadedResourceFromMemoryCache(const CachedResource*);
void tellClientAboutPastMemoryCacheLoads();
void checkLoadComplete();
void detachFromParent();
void detachViewsAndDocumentLoader();
void addExtraFieldsToSubresourceRequest(ResourceRequest&);
void addExtraFieldsToMainResourceRequest(ResourceRequest&);
static void addHTTPOriginIfNeeded(ResourceRequest&, String origin);
FrameLoaderClient* client() const { return m_client; }
void setDefersLoading(bool);
void changeLocation(PassRefPtr<SecurityOrigin>, const KURL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool userGesture = false, bool refresh = false);
void urlSelected(const KURL&, const String& target, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, bool userGesture, ReferrerPolicy);
bool requestFrame(HTMLFrameOwnerElement*, const String& url, const AtomicString& frameName, bool lockHistory = true, bool lockBackForwardList = true);
void submitForm(const char* action, const String& url,
PassRefPtr<FormData>, const String& target, const String& contentType, const String& boundary,
bool lockHistory, PassRefPtr<Event>, PassRefPtr<FormState>);
void stop();
void stopLoading(UnloadEventPolicy, DatabasePolicy = DatabasePolicyStop);
bool closeURL();
void didExplicitOpen();
void didBeginDocument(bool dispatchWindowObjectAvailable);
void didEndDocument();
void willSetEncoding();
KURL iconURL();
void commitIconURLToIconDatabase(const KURL&);
KURL baseURL() const;
void tokenizerProcessedData();
void handledOnloadEvents();
String userAgent(const KURL&) const;
PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const HashMap<String, String>& args);
void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
void dispatchDidClearWindowObjectsInAllWorlds();
void dispatchDocumentElementAvailable();
void ownerElementSandboxFlagsChanged() { updateSandboxFlags(); }
bool isSandboxed(SandboxFlags mask) const { return m_sandboxFlags & mask; }
SandboxFlags sandboxFlags() const { return m_sandboxFlags; }
void setForcedSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags = flags; m_sandboxFlags |= flags; }
static bool isMixedContent(SecurityOrigin* context, const KURL&);
void checkIfDisplayInsecureContent(SecurityOrigin* context, const KURL&);
void checkIfRunInsecureContent(SecurityOrigin* context, const KURL&);
Frame* opener();
void setOpener(Frame*);
bool isProcessingUserGesture();
void resetMultipleFormSubmissionProtection();
void addData(const char* bytes, int length);
void checkCallImplicitClose();
void frameDetached();
const KURL& url() const { return m_URL; }
void setURL(const KURL&);
bool allowPlugins(ReasonForCallingAllowPlugins);
bool containsPlugins() const;
void loadDone();
void finishedParsing();
void checkCompleted();
void checkDidPerformFirstNavigation();
bool isComplete() const;
bool requestObject(RenderEmbeddedObject*, const String& url, const AtomicString& frameName,
const String& serviceType, const Vector<String>& paramNames, const Vector<String>& paramValues);
KURL completeURL(const String& url);
void cancelAndClear();
void setTitle(const String&);
void setIconURL(const String&);
void commitProvisionalLoad(PassRefPtr<CachedPage>);
bool isLoadingFromCachedPage() const { return m_loadingFromCachedPage; }
bool committingFirstRealLoad() const { return !m_creatingInitialEmptyDocument && !m_committedFirstRealDocumentLoad; }
bool committedFirstRealDocumentLoad() const { return m_committedFirstRealDocumentLoad; }
bool creatingInitialEmptyDocument() const { return m_creatingInitialEmptyDocument; }
void iconLoadDecisionAvailable();
bool shouldAllowNavigation(Frame* targetFrame) const;
Frame* findFrameForNavigation(const AtomicString& name);
void startIconLoader();
void applyUserAgent(ResourceRequest& request);
bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&);
void open(CachedFrameBase&);
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
PassRefPtr<Widget> loadMediaPlayerProxyPlugin(Node*, const KURL&, const Vector<String>& paramNames, const Vector<String>& paramValues);
#endif
void completed();
bool allAncestorsAreComplete() const; bool allChildrenAreComplete() const; void clientRedirected(const KURL&, double delay, double fireDate, bool lockBackForwardList);
void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
void loadItem(HistoryItem*, FrameLoadType);
void continueLoadAfterWillSubmitForm();
bool suppressOpenerInNewFrame() const { return m_suppressOpenerInNewFrame; }
static ObjectContentType defaultObjectContentType(const KURL& url, const String& mimeType);
bool isDisplayingInitialEmptyDocument() const { return m_isDisplayingInitialEmptyDocument; }
void clear(bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true);
bool shouldClose();
private:
bool canCachePageContainingThisFrame();
#ifndef NDEBUG
void logCanCachePageDecision();
bool logCanCacheFrameDecision(int indentLevel);
#endif
void checkTimerFired(Timer<FrameLoader>*);
void started();
bool shouldUsePlugin(const KURL&, const String& mimeType, bool hasFallback, bool& useFallback);
bool loadPlugin(RenderEmbeddedObject*, const KURL&, const String& mimeType,
const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback);
void navigateWithinDocument(HistoryItem*);
void navigateToDifferentDocument(HistoryItem*, FrameLoadType);
bool loadProvisionalItemFromCachedPage();
void cachePageForHistoryItem(HistoryItem*);
void receivedFirstData();
void updateFirstPartyForCookies();
void setFirstPartyForCookies(const KURL&);
void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType loadType, bool isMainResource, bool cookiePolicyURLFromRequest);
void stopLoadingSubframes();
void clearProvisionalLoad();
void markLoadComplete();
void transitionToCommitted(PassRefPtr<CachedPage>);
void frameLoadCompleted();
void mainReceivedError(const ResourceError&, bool isComplete);
void setLoadType(FrameLoadType);
static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
bool shouldScrollToAnchor(bool isFormSubmission, FrameLoadType, const KURL&);
void checkLoadCompleteForThisFrame();
void setDocumentLoader(DocumentLoader*);
void setPolicyDocumentLoader(DocumentLoader*);
void setProvisionalDocumentLoader(DocumentLoader*);
void setState(FrameState);
void closeOldDataSources();
void open(CachedPage&);
void updateHistoryAfterClientRedirect();
bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
void dispatchDidCommitLoad();
void urlSelected(const FrameLoadRequest&, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, bool userGesture, ReferrerPolicy, ShouldReplaceDocumentIfJavaScriptURL);
void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>); void load(DocumentLoader*);
void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&, bool lockHistory, FrameLoadType, PassRefPtr<FormState>);
void loadPostRequest(const ResourceRequest&, const String& referrer, const String& frameName, bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
void loadURL(const KURL&, const String& referrer, const String& frameName, bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
void recursiveCheckLoadComplete();
void detachChildren();
void closeAndRemoveChild(Frame*);
Frame* loadOrRedirectSubframe(HTMLFrameOwnerElement*, const KURL&, const AtomicString& frameName, bool lockHistory, bool lockBackForwardList);
Frame* loadSubframe(HTMLFrameOwnerElement*, const KURL&, const String& name, const String& referrer);
void loadInSameDocument(const KURL&, SerializedScriptValue* stateObject, bool isNewNavigation);
void provisionalLoadStarted();
bool canCachePage();
bool didOpenURL(const KURL&);
void scheduleCheckCompleted();
void scheduleCheckLoadComplete();
void startCheckCompleteTimer();
KURL originalRequestURL() const;
bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
void updateSandboxFlags();
bool isDocumentSandboxed(SandboxFlags) const;
Frame* m_frame;
FrameLoaderClient* m_client;
mutable PolicyChecker m_policyChecker;
mutable HistoryController m_history;
mutable ResourceLoadNotifier m_notifer;
mutable DocumentWriter m_writer;
FrameState m_state;
FrameLoadType m_loadType;
RefPtr<DocumentLoader> m_documentLoader;
RefPtr<DocumentLoader> m_provisionalDocumentLoader;
RefPtr<DocumentLoader> m_policyDocumentLoader;
bool m_delegateIsHandlingProvisionalLoadError;
bool m_firstLayoutDone;
bool m_quickRedirectComing;
bool m_sentRedirectNotification;
bool m_inStopAllLoaders;
String m_outgoingReferrer;
bool m_isExecutingJavaScriptFormAction;
bool m_didCallImplicitClose;
bool m_wasUnloadEventEmitted;
bool m_pageDismissalEventBeingDispatched;
bool m_isComplete;
bool m_isLoadingMainResource;
RefPtr<SerializedScriptValue> m_pendingStateObject;
KURL m_URL;
KURL m_workingURL;
OwnPtr<IconLoader> m_iconLoader;
bool m_mayLoadIconLater;
bool m_cancellingWithLoadInProgress;
bool m_needsClear;
bool m_receivedData;
bool m_containsPlugIns;
KURL m_submittedFormURL;
Timer<FrameLoader> m_checkTimer;
bool m_shouldCallCheckCompleted;
bool m_shouldCallCheckLoadComplete;
Frame* m_opener;
HashSet<Frame*> m_openedFrames;
bool m_creatingInitialEmptyDocument;
bool m_isDisplayingInitialEmptyDocument;
bool m_committedFirstRealDocumentLoad;
bool m_didPerformFirstNavigation;
bool m_loadingFromCachedPage;
bool m_suppressOpenerInNewFrame;
SandboxFlags m_sandboxFlags;
SandboxFlags m_forcedSandboxFlags;
#ifndef NDEBUG
bool m_didDispatchDidCommitLoad;
#endif
};
}
#endif // FrameLoader_h