Use normal loading path for ping loads
[WebKit-https.git] / Source / WebCore / loader / LoaderStrategy.h
index 35c0494..8a82381 100644 (file)
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef LoaderStrategy_h
-#define LoaderStrategy_h
+#pragma once
 
-#include "ResourceHandleTypes.h"
+#include "FetchOptions.h"
 #include "ResourceLoadPriority.h"
 #include "ResourceLoaderOptions.h"
-#include <wtf/Vector.h>
+#include "StoredCredentialsPolicy.h"
+#include <pal/SessionID.h>
+#include <wtf/Forward.h>
 
 namespace WebCore {
 
-class BlobRegistry;
 class CachedResource;
+class ContentSecurityPolicy;
 class Frame;
+class FrameLoader;
+class HTTPHeaderMap;
 class NetscapePlugInStreamLoader;
 class NetscapePlugInStreamLoaderClient;
-class NetworkingContext;
+struct NetworkTransactionInformation;
+class NetworkLoadMetrics;
 class ResourceError;
 class ResourceLoader;
 class ResourceRequest;
 class ResourceResponse;
+class SecurityOrigin;
+class SharedBuffer;
 class SubresourceLoader;
-class URL;
+
+struct FetchOptions;
 
 class WEBCORE_EXPORT LoaderStrategy {
 public:
-    virtual RefPtr<SubresourceLoader> loadResource(Frame*, CachedResource*, const ResourceRequest&, const ResourceLoaderOptions&) = 0;
-    virtual void loadResourceSynchronously(NetworkingContext*, unsigned long identifier, const ResourceRequest&, StoredCredentials, ClientCredentialPolicy, ResourceError&, ResourceResponse&, Vector<char>& data) = 0;
+    virtual void loadResource(Frame&, CachedResource&, ResourceRequest&&, const ResourceLoaderOptions&, CompletionHandler<void(RefPtr<SubresourceLoader>&&)>&&) = 0;
+    virtual void loadResourceSynchronously(FrameLoader&, unsigned long identifier, const ResourceRequest&, ClientCredentialPolicy, const FetchOptions&, const HTTPHeaderMap&, ResourceError&, ResourceResponse&, Vector<char>& data) = 0;
+    virtual void pageLoadCompleted(uint64_t webPageID) = 0;
 
     virtual void remove(ResourceLoader*) = 0;
-    virtual void setDefersLoading(ResourceLoader*, bool) = 0;
+    virtual void setDefersLoading(ResourceLoader&, bool) = 0;
     virtual void crossOriginRedirectReceived(ResourceLoader*, const URL& redirectURL) = 0;
 
     virtual void servePendingRequests(ResourceLoadPriority minimumPriority = ResourceLoadPriority::VeryLow) = 0;
     virtual void suspendPendingRequests() = 0;
     virtual void resumePendingRequests() = 0;
 
-    virtual void createPingHandle(NetworkingContext*, ResourceRequest&, bool shouldUseCredentialStorage) = 0;
+    virtual bool usePingLoad() const { return true; }
+    using PingLoadCompletionHandler = WTF::Function<void(const ResourceError&, const ResourceResponse&)>;
+    virtual void startPingLoad(Frame&, ResourceRequest&, const HTTPHeaderMap& originalRequestHeaders, const FetchOptions&, ContentSecurityPolicyImposition, PingLoadCompletionHandler&& = { }) = 0;
+
+    using PreconnectCompletionHandler = WTF::Function<void(const ResourceError&)>;
+    virtual void preconnectTo(FrameLoader&, const URL&, StoredCredentialsPolicy, PreconnectCompletionHandler&&) = 0;
+
+    virtual void setCaptureExtraNetworkLoadMetricsEnabled(bool) = 0;
+
+    virtual bool isOnLine() const = 0;
+    virtual void addOnlineStateChangeListener(WTF::Function<void(bool)>&&) = 0;
+
+    virtual bool shouldPerformSecurityChecks() const { return false; }
+    virtual bool havePerformedSecurityChecks(const ResourceResponse&) const { return false; }
+
+    virtual ResourceResponse responseFromResourceLoadIdentifier(uint64_t resourceLoadIdentifier);
+    virtual Vector<NetworkTransactionInformation> intermediateLoadInformationFromResourceLoadIdentifier(uint64_t resourceLoadIdentifier);
+    virtual NetworkLoadMetrics networkMetricsFromResourceLoadIdentifier(uint64_t resourceLoadIdentifier);
+
+    // Used for testing only.
+    virtual Vector<uint64_t> ongoingLoads() const { return { }; }
 
 protected:
     virtual ~LoaderStrategy();
 };
 
-class ResourceLoadSuspender {
-public:
-    ResourceLoadSuspender();
-    ~ResourceLoadSuspender();
-};
-
 } // namespace WebCore
-
-#endif // LoaderStrategy_h