#pragma once
#include "CachedRawResourceClient.h"
#include "CachedResourceHandle.h"
#include "DocumentWriter.h"
#include "IconDatabaseBase.h"
#include "LinkIcon.h"
#include "LoadTiming.h"
#include "NavigationAction.h"
#include "ResourceError.h"
#include "ResourceLoaderOptions.h"
#include "ResourceRequest.h"
#include "ResourceResponse.h"
#include "StringWithDirection.h"
#include "StyleSheetContents.h"
#include "SubstituteData.h"
#include "Timer.h"
#include <wtf/HashSet.h>
#include <wtf/RefPtr.h>
#include <wtf/Vector.h>
#if HAVE(RUNLOOP_TIMER)
#include <wtf/RunLoopTimer.h>
#endif
#if USE(QUICK_LOOK)
#include "QuickLook.h"
#endif
#if PLATFORM(COCOA) && !USE(CFURLCONNECTION)
#include <wtf/SchedulePair.h>
#endif
namespace WebCore {
class ApplicationCacheHost;
class Archive;
class ArchiveResource;
class ArchiveResourceCollection;
class CachedRawResource;
class CachedResourceLoader;
class ContentFilter;
class FormState;
class Frame;
class FrameLoader;
class IconLoader;
class Page;
class ResourceLoader;
class SharedBuffer;
class SubresourceLoader;
class SubstituteResource;
typedef HashMap<unsigned long, RefPtr<ResourceLoader>> ResourceLoaderMap;
typedef Vector<ResourceResponse> ResponseVector;
class DocumentLoader : public RefCounted<DocumentLoader>, private CachedRawResourceClient {
WTF_MAKE_FAST_ALLOCATED;
friend class ContentFilter;
public:
static Ref<DocumentLoader> create(const ResourceRequest& request, const SubstituteData& data)
{
return adoptRef(*new DocumentLoader(request, data));
}
WEBCORE_EXPORT virtual ~DocumentLoader();
void attachToFrame(Frame&);
Frame* frame() const { return m_frame; }
WEBCORE_EXPORT virtual void detachFromFrame();
WEBCORE_EXPORT FrameLoader* frameLoader() const;
WEBCORE_EXPORT SubresourceLoader* mainResourceLoader() const;
WEBCORE_EXPORT RefPtr<SharedBuffer> mainResourceData() const;
DocumentWriter& writer() const { return m_writer; }
WEBCORE_EXPORT const ResourceRequest& originalRequest() const;
WEBCORE_EXPORT const ResourceRequest& originalRequestCopy() const;
WEBCORE_EXPORT const ResourceRequest& request() const;
WEBCORE_EXPORT ResourceRequest& request();
CachedResourceLoader& cachedResourceLoader() { return m_cachedResourceLoader; }
const SubstituteData& substituteData() const { return m_substituteData; }
WEBCORE_EXPORT const URL& url() const;
WEBCORE_EXPORT const URL& unreachableURL() const;
const URL& originalURL() const;
WEBCORE_EXPORT const URL& responseURL() const;
WEBCORE_EXPORT const String& responseMIMEType() const;
#if PLATFORM(IOS)
WEBCORE_EXPORT void setResponseMIMEType(const String&);
#endif
const String& currentContentType() const;
void replaceRequestURLForSameDocumentNavigation(const URL&);
bool isStopping() const { return m_isStopping; }
void stopLoading();
void setCommitted(bool committed) { m_committed = committed; }
bool isCommitted() const { return m_committed; }
WEBCORE_EXPORT bool isLoading() const;
const ResourceError& mainDocumentError() const { return m_mainDocumentError; }
const ResourceResponse& response() const { return m_response; }
#if PLATFORM(IOS)
void setResponse(const ResourceResponse& response) { m_response = response; }
#endif
bool isClientRedirect() const { return m_isClientRedirect; }
void setIsClientRedirect(bool isClientRedirect) { m_isClientRedirect = isClientRedirect; }
void dispatchOnloadEvents();
bool wasOnloadDispatched() { return m_wasOnloadDispatched; }
WEBCORE_EXPORT bool isLoadingInAPISense() const;
WEBCORE_EXPORT void setTitle(const StringWithDirection&);
const String& overrideEncoding() const { return m_overrideEncoding; }
#if PLATFORM(COCOA) && !USE(CFURLCONNECTION)
void schedule(SchedulePair&);
void unschedule(SchedulePair&);
#endif
#if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
void setArchive(PassRefPtr<Archive>);
WEBCORE_EXPORT void addAllArchiveResources(Archive*);
WEBCORE_EXPORT void addArchiveResource(Ref<ArchiveResource>&&);
PassRefPtr<Archive> popArchiveForSubframe(const String& frameName, const URL&);
WEBCORE_EXPORT SharedBuffer* parsedArchiveData() const;
WEBCORE_EXPORT bool scheduleArchiveLoad(ResourceLoader&, const ResourceRequest&);
#endif
void scheduleSubstituteResourceLoad(ResourceLoader&, SubstituteResource&);
WEBCORE_EXPORT ArchiveResource* archiveResourceForURL(const URL&) const;
WEBCORE_EXPORT RefPtr<ArchiveResource> mainResource() const;
WEBCORE_EXPORT PassRefPtr<ArchiveResource> subresource(const URL&) const;
WEBCORE_EXPORT Vector<RefPtr<ArchiveResource>> subresources() const;
#ifndef NDEBUG
bool isSubstituteLoadPending(ResourceLoader*) const;
#endif
void cancelPendingSubstituteLoad(ResourceLoader*);
void addResponse(const ResourceResponse&);
const ResponseVector& responses() const { return m_responses; }
const NavigationAction& triggeringAction() const { return m_triggeringAction; }
void setTriggeringAction(const NavigationAction&);
void setOverrideEncoding(const String& encoding) { m_overrideEncoding = encoding; }
void setLastCheckedRequest(const ResourceRequest& request) { m_lastCheckedRequest = request; }
const ResourceRequest& lastCheckedRequest() { return m_lastCheckedRequest; }
void stopRecordingResponses();
const StringWithDirection& title() const { return m_pageTitle; }
WEBCORE_EXPORT URL urlForHistory() const;
WEBCORE_EXPORT bool urlForHistoryReflectsFailure() const;
String clientRedirectSourceForHistory() const { return m_clientRedirectSourceForHistory; } String clientRedirectDestinationForHistory() const { return urlForHistory(); }
void setClientRedirectSourceForHistory(const String& clientRedirectSourceForHistory) { m_clientRedirectSourceForHistory = clientRedirectSourceForHistory; }
String serverRedirectSourceForHistory() const { return (urlForHistory() == url() || url() == blankURL()) ? String() : urlForHistory().string(); } String serverRedirectDestinationForHistory() const { return url(); }
bool didCreateGlobalHistoryEntry() const { return m_didCreateGlobalHistoryEntry; }
void setDidCreateGlobalHistoryEntry(bool didCreateGlobalHistoryEntry) { m_didCreateGlobalHistoryEntry = didCreateGlobalHistoryEntry; }
bool subresourceLoadersArePageCacheAcceptable() const { return m_subresourceLoadersArePageCacheAcceptable; }
void setDefersLoading(bool);
void setMainResourceDataBufferingPolicy(DataBufferingPolicy);
void startLoadingMainResource();
WEBCORE_EXPORT void cancelMainResourceLoad(const ResourceError&);
void willContinueMainResourceLoadAfterRedirect(const ResourceRequest&);
void iconLoadDecisionAvailable();
void continueIconLoadWithDecision(IconLoadDecision);
void getIconLoadDecisionForIconURL(const String&);
void getIconDataForIconURL(const String&);
bool isLoadingMainResource() const { return m_loadingMainResource; }
bool isLoadingMultipartContent() const { return m_isLoadingMultipartContent; }
void stopLoadingPlugIns();
void stopLoadingSubresources();
bool userContentExtensionsEnabled() const { return m_userContentExtensionsEnabled; }
void setUserContentExtensionsEnabled(bool enabled) { m_userContentExtensionsEnabled = enabled; }
void addSubresourceLoader(ResourceLoader*);
void removeSubresourceLoader(ResourceLoader*);
void addPlugInStreamLoader(ResourceLoader&);
void removePlugInStreamLoader(ResourceLoader&);
void subresourceLoaderFinishedLoadingOnePart(ResourceLoader*);
void setDeferMainResourceDataLoad(bool defer) { m_deferMainResourceDataLoad = defer; }
void didTellClientAboutLoad(const String& url)
{
#if !PLATFORM(COCOA)
if (protocolIs(url, "data"))
return;
#endif
if (!url.isEmpty())
m_resourcesClientKnowsAbout.add(url);
}
bool haveToldClientAboutLoad(const String& url) { return m_resourcesClientKnowsAbout.contains(url); }
void recordMemoryCacheLoadForFutureClientNotification(const ResourceRequest&);
void takeMemoryCacheLoadsForClientNotification(Vector<ResourceRequest>& loads);
LoadTiming& timing() { return m_loadTiming; }
void resetTiming() { m_loadTiming = LoadTiming(); }
WEBCORE_EXPORT void commitData(const char* bytes, size_t length);
ApplicationCacheHost* applicationCacheHost() const { return m_applicationCacheHost.get(); }
void checkLoadComplete();
URL documentURL() const;
#if USE(QUICK_LOOK)
void setQuickLookHandle(std::unique_ptr<QuickLookHandle> quickLookHandle) { m_quickLookHandle = WTFMove(quickLookHandle); }
QuickLookHandle* quickLookHandle() const { return m_quickLookHandle.get(); }
#endif
#if ENABLE(CONTENT_EXTENSIONS)
void addPendingContentExtensionSheet(const String& identifier, StyleSheetContents&);
void addPendingContentExtensionDisplayNoneSelector(const String& identifier, const String& selector, uint32_t selectorID);
#endif
void setShouldOpenExternalURLsPolicy(ShouldOpenExternalURLsPolicy shouldOpenExternalURLsPolicy) { m_shouldOpenExternalURLsPolicy = shouldOpenExternalURLsPolicy; }
ShouldOpenExternalURLsPolicy shouldOpenExternalURLsPolicyToPropagate() const;
#if ENABLE(CONTENT_FILTERING)
ContentFilter* contentFilter() const;
#endif
bool isAlwaysOnLoggingAllowed() const;
void startIconLoading();
WEBCORE_EXPORT void didGetLoadDecisionForIcon(bool decision, uint64_t loadIdentifier, uint64_t newCallbackID);
void finishedLoadingIcon(IconLoader&, SharedBuffer*);
protected:
WEBCORE_EXPORT DocumentLoader(const ResourceRequest&, const SubstituteData&);
WEBCORE_EXPORT virtual void attachToFrame();
bool m_deferMainResourceDataLoad;
private:
Document* document() const;
void setRequest(const ResourceRequest&);
void commitIfReady();
void setMainDocumentError(const ResourceError&);
void commitLoad(const char*, int);
void clearMainResourceLoader();
void setupForReplace();
void maybeFinishLoadingMultipartContent();
bool maybeCreateArchive();
#if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
void clearArchiveResources();
#endif
void willSendRequest(ResourceRequest&, const ResourceResponse&);
void finishedLoading(double finishTime);
void mainReceivedError(const ResourceError&);
WEBCORE_EXPORT void redirectReceived(CachedResource&, ResourceRequest&, const ResourceResponse&) override;
WEBCORE_EXPORT void responseReceived(CachedResource&, const ResourceResponse&) override;
WEBCORE_EXPORT void dataReceived(CachedResource&, const char* data, int length) override;
WEBCORE_EXPORT void notifyFinished(CachedResource&) override;
void responseReceived(const ResourceResponse&);
void dataReceived(const char* data, int length);
bool maybeLoadEmpty();
bool isMultipartReplacingLoad() const;
bool isPostOrRedirectAfterPost(const ResourceRequest&, const ResourceResponse&);
void continueAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
void continueAfterContentPolicy(PolicyAction);
void stopLoadingForPolicyChange();
ResourceError interruptedForPolicyChangeError() const;
void stopLoadingAfterXFrameOptionsOrContentSecurityPolicyDenied(unsigned long identifier, const ResourceResponse&);
#if HAVE(RUNLOOP_TIMER)
typedef RunLoopTimer<DocumentLoader> DocumentLoaderTimer;
#else
typedef Timer DocumentLoaderTimer;
#endif
void handleSubstituteDataLoadSoon();
void handleSubstituteDataLoadNow();
void startDataLoadTimer();
void deliverSubstituteResourcesAfterDelay();
void substituteResourceDeliveryTimerFired();
void clearMainResource();
void cancelPolicyCheckIfNeeded();
void becomeMainResourceClient();
Frame* m_frame;
Ref<CachedResourceLoader> m_cachedResourceLoader;
CachedResourceHandle<CachedRawResource> m_mainResource;
ResourceLoaderMap m_subresourceLoaders;
ResourceLoaderMap m_multipartSubresourceLoaders;
ResourceLoaderMap m_plugInStreamLoaders;
mutable DocumentWriter m_writer;
ResourceRequest m_originalRequest;
SubstituteData m_substituteData;
ResourceRequest m_originalRequestCopy;
ResourceRequest m_request;
ResourceResponse m_response;
ResourceError m_mainDocumentError;
bool m_originalSubstituteDataWasValid;
bool m_committed;
bool m_isStopping;
bool m_gotFirstByte;
bool m_isClientRedirect;
bool m_isLoadingMultipartContent;
bool m_wasOnloadDispatched;
StringWithDirection m_pageTitle;
String m_overrideEncoding;
NavigationAction m_triggeringAction;
ResourceRequest m_lastCheckedRequest;
ResponseVector m_responses;
bool m_stopRecordingResponses;
typedef HashMap<RefPtr<ResourceLoader>, RefPtr<SubstituteResource>> SubstituteResourceMap;
SubstituteResourceMap m_pendingSubstituteResources;
Timer m_substituteResourceDeliveryTimer;
std::unique_ptr<ArchiveResourceCollection> m_archiveResourceCollection;
#if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
RefPtr<Archive> m_archive;
RefPtr<SharedBuffer> m_parsedArchiveData;
#endif
HashSet<String> m_resourcesClientKnowsAbout;
Vector<ResourceRequest> m_resourcesLoadedFromMemoryCacheForClientNotification;
String m_clientRedirectSourceForHistory;
bool m_didCreateGlobalHistoryEntry;
bool m_loadingMainResource;
LoadTiming m_loadTiming;
double m_timeOfLastDataReceived;
unsigned long m_identifierForLoadWithoutResourceLoader;
DocumentLoaderTimer m_dataLoadTimer;
bool m_waitingForContentPolicy { false };
bool m_waitingForNavigationPolicy { false };
RefPtr<IconLoadDecisionCallback> m_iconLoadDecisionCallback;
RefPtr<IconDataCallback> m_iconDataCallback;
HashMap<uint64_t, LinkIcon> m_iconsPendingLoadDecision;
HashMap<std::unique_ptr<IconLoader>, uint64_t> m_iconLoaders;
bool m_subresourceLoadersArePageCacheAcceptable;
ShouldOpenExternalURLsPolicy m_shouldOpenExternalURLsPolicy { ShouldOpenExternalURLsPolicy::ShouldNotAllow };
std::unique_ptr<ApplicationCacheHost> m_applicationCacheHost;
#if ENABLE(CONTENT_FILTERING)
std::unique_ptr<ContentFilter> m_contentFilter;
#endif
#if USE(QUICK_LOOK)
std::unique_ptr<QuickLookHandle> m_quickLookHandle;
#endif
#if ENABLE(CONTENT_EXTENSIONS)
HashMap<String, RefPtr<StyleSheetContents>> m_pendingNamedContentExtensionStyleSheets;
HashMap<String, Vector<std::pair<String, uint32_t>>> m_pendingContentExtensionDisplayNoneSelectors;
#endif
bool m_userContentExtensionsEnabled { true };
#ifndef NDEBUG
bool m_hasEverBeenAttached { false };
#endif
};
inline void DocumentLoader::recordMemoryCacheLoadForFutureClientNotification(const ResourceRequest& request)
{
m_resourcesLoadedFromMemoryCacheForClientNotification.append(request);
}
inline void DocumentLoader::takeMemoryCacheLoadsForClientNotification(Vector<ResourceRequest>& loadsSet)
{
loadsSet.swap(m_resourcesLoadedFromMemoryCacheForClientNotification);
m_resourcesLoadedFromMemoryCacheForClientNotification.clear();
}
}