Web Inspector: provide a way to edit the user agent of a remote target
[WebKit-https.git] / Source / WebCore / loader / ResourceLoader.h
1 /*
2  * Copyright (C) 2005-2017 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer. 
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution. 
13  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission. 
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #pragma once
30
31 #include "LoadTiming.h"
32 #include "ResourceHandleClient.h"
33 #include "ResourceLoaderOptions.h"
34 #include "ResourceLoaderTypes.h"
35 #include "ResourceRequest.h"
36 #include "ResourceResponse.h"
37 #include <wtf/Forward.h>
38
39 #if ENABLE(CONTENT_EXTENSIONS)
40 #include "ResourceLoadInfo.h"
41 #endif
42
43 namespace WTF {
44 class SchedulePair;
45 }
46
47 namespace WebCore {
48
49 class AuthenticationChallenge;
50 class DocumentLoader;
51 class Frame;
52 class FrameLoader;
53 class NetworkLoadMetrics;
54 class PreviewLoader;
55
56 class ResourceLoader : public RefCounted<ResourceLoader>, protected ResourceHandleClient {
57 public:
58     virtual ~ResourceLoader() = 0;
59
60     WEBCORE_EXPORT void cancel();
61
62     virtual void init(ResourceRequest&&, CompletionHandler<void(bool)>&&);
63
64     void deliverResponseAndData(const ResourceResponse&, RefPtr<SharedBuffer>&&);
65
66 #if PLATFORM(IOS_FAMILY)
67     virtual void startLoading()
68     {
69         start();
70     }
71
72     virtual const ResourceRequest& iOSOriginalRequest() const { return request(); }
73 #endif
74
75     WEBCORE_EXPORT FrameLoader* frameLoader() const;
76     DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
77     const ResourceRequest& originalRequest() const { return m_originalRequest; }
78
79     WEBCORE_EXPORT void start();
80     WEBCORE_EXPORT void cancel(const ResourceError&);
81     WEBCORE_EXPORT ResourceError cancelledError();
82     ResourceError blockedError();
83     ResourceError blockedByContentBlockerError();
84     ResourceError cannotShowURLError();
85     
86     virtual void setDefersLoading(bool);
87     bool defersLoading() const { return m_defersLoading; }
88
89     unsigned long identifier() const { return m_identifier; }
90
91     bool wasAuthenticationChallengeBlocked() const { return m_wasAuthenticationChallengeBlocked; }
92
93     virtual void releaseResources();
94     const ResourceResponse& response() const { return m_response; }
95
96     SharedBuffer* resourceData() const { return m_resourceData.get(); }
97     void clearResourceData();
98     
99     virtual bool isSubresourceLoader() const;
100
101     virtual void willSendRequest(ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&& callback);
102     virtual void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent);
103     virtual void didReceiveResponse(const ResourceResponse&, CompletionHandler<void()>&& policyCompletionHandler);
104     virtual void didReceiveData(const char*, unsigned, long long encodedDataLength, DataPayloadType);
105     virtual void didReceiveBuffer(Ref<SharedBuffer>&&, long long encodedDataLength, DataPayloadType);
106     virtual void didFinishLoading(const NetworkLoadMetrics&);
107     virtual void didFail(const ResourceError&);
108
109     WEBCORE_EXPORT void didBlockAuthenticationChallenge();
110
111     virtual bool shouldUseCredentialStorage();
112 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
113     virtual bool canAuthenticateAgainstProtectionSpace(const ProtectionSpace&);
114 #endif
115     virtual void receivedCancellation(const AuthenticationChallenge&);
116
117 #if USE(QUICK_LOOK)
118     bool isQuickLookResource() const;
119 #endif
120
121     const URL& url() const { return m_request.url(); }
122     ResourceHandle* handle() const { return m_handle.get(); }
123     bool shouldSendResourceLoadCallbacks() const { return m_options.sendLoadCallbacks == SendCallbackPolicy::SendCallbacks; }
124     void setSendCallbackPolicy(SendCallbackPolicy sendLoadCallbacks) { m_options.sendLoadCallbacks = sendLoadCallbacks; }
125     bool shouldSniffContent() const { return m_options.sniffContent == ContentSniffingPolicy::SniffContent; }
126     bool shouldSniffContentEncoding() const { return m_options.sniffContentEncoding == ContentEncodingSniffingPolicy::Sniff; }
127     WEBCORE_EXPORT bool isAllowedToAskUserForCredentials() const;
128     WEBCORE_EXPORT bool shouldIncludeCertificateInfo() const;
129
130     bool reachedTerminalState() const { return m_reachedTerminalState; }
131
132
133     const ResourceRequest& request() const { return m_request; }
134     void setRequest(ResourceRequest&& request) { m_request = WTFMove(request); }
135
136     void setDataBufferingPolicy(DataBufferingPolicy);
137
138     void willSwitchToSubstituteResource();
139
140     const LoadTiming& loadTiming() { return m_loadTiming; }
141
142 #if PLATFORM(COCOA)
143     void schedule(WTF::SchedulePair&);
144     void unschedule(WTF::SchedulePair&);
145 #endif
146
147     const Frame* frame() const { return m_frame.get(); }
148     WEBCORE_EXPORT bool isAlwaysOnLoggingAllowed() const;
149
150     const ResourceLoaderOptions& options() const { return m_options; }
151
152     const ResourceRequest& deferredRequest() const { return m_deferredRequest; }
153     ResourceRequest takeDeferredRequest() { return std::exchange(m_deferredRequest, { }); }
154
155 protected:
156     ResourceLoader(Frame&, ResourceLoaderOptions);
157
158     void didFinishLoadingOnePart(const NetworkLoadMetrics&);
159     void cleanupForError(const ResourceError&);
160
161     bool wasCancelled() const { return m_cancellationStatus >= Cancelled; }
162
163     void didReceiveDataOrBuffer(const char*, unsigned, RefPtr<SharedBuffer>&&, long long encodedDataLength, DataPayloadType);
164     
165     void setReferrerPolicy(ReferrerPolicy referrerPolicy) { m_options.referrerPolicy = referrerPolicy; }
166     ReferrerPolicy referrerPolicy() const { return m_options.referrerPolicy; }
167
168 #if PLATFORM(COCOA)
169     void willCacheResponseAsync(ResourceHandle*, NSCachedURLResponse*, CompletionHandler<void(NSCachedURLResponse *)>&&) override;
170 #endif
171
172     virtual void willSendRequestInternal(ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&&);
173
174     RefPtr<ResourceHandle> m_handle;
175     RefPtr<Frame> m_frame;
176     RefPtr<DocumentLoader> m_documentLoader;
177     ResourceResponse m_response;
178     LoadTiming m_loadTiming;
179 #if USE(QUICK_LOOK)
180     std::unique_ptr<PreviewLoader> m_previewLoader;
181 #endif
182     bool m_canCrossOriginRequestsAskUserForCredentials { true };
183
184 private:
185     virtual void willCancel(const ResourceError&) = 0;
186     virtual void didCancel(const ResourceError&) = 0;
187
188     void addDataOrBuffer(const char*, unsigned, SharedBuffer*, DataPayloadType);
189     void loadDataURL();
190     void finishNetworkLoad();
191
192     bool shouldAllowResourceToAskForCredentials() const;
193
194     // ResourceHandleClient
195     void didSendData(ResourceHandle*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
196     void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&, CompletionHandler<void()>&&) override;
197     void willSendRequestAsync(ResourceHandle*, ResourceRequest&&, ResourceResponse&&, CompletionHandler<void(ResourceRequest&&)>&&) override;
198     void didReceiveData(ResourceHandle*, const char*, unsigned, int encodedDataLength) override;
199     void didReceiveBuffer(ResourceHandle*, Ref<SharedBuffer>&&, int encodedDataLength) override;
200     void didFinishLoading(ResourceHandle*) override;
201     void didFail(ResourceHandle*, const ResourceError&) override;
202     void wasBlocked(ResourceHandle*) override;
203     void cannotShowURL(ResourceHandle*) override;
204     bool shouldUseCredentialStorage(ResourceHandle*) override { return shouldUseCredentialStorage(); }
205     void didReceiveAuthenticationChallenge(ResourceHandle*, const AuthenticationChallenge&) override;
206 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
207     void canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle*, const ProtectionSpace&, CompletionHandler<void(bool)>&&) override;
208 #endif
209     void receivedCancellation(ResourceHandle*, const AuthenticationChallenge& challenge) override { receivedCancellation(challenge); }
210 #if PLATFORM(IOS_FAMILY)
211     RetainPtr<CFDictionaryRef> connectionProperties(ResourceHandle*) override;
212 #endif
213 #if USE(CFURLCONNECTION)
214     // FIXME: Windows should use willCacheResponse - <https://bugs.webkit.org/show_bug.cgi?id=57257>.
215     bool shouldCacheResponse(ResourceHandle*, CFCachedURLResponseRef) override;
216 #endif
217
218 #if USE(SOUP)
219     void loadGResource();
220 #endif
221
222     ResourceRequest m_request;
223     ResourceRequest m_originalRequest; // Before redirects.
224     RefPtr<SharedBuffer> m_resourceData;
225     
226     unsigned long m_identifier { 0 };
227
228     bool m_reachedTerminalState { false };
229     bool m_notifiedLoadComplete { false };
230
231     enum CancellationStatus {
232         NotCancelled,
233         CalledWillCancel,
234         Cancelled,
235         FinishedCancel
236     };
237     CancellationStatus m_cancellationStatus { NotCancelled };
238
239     bool m_defersLoading;
240     bool m_wasAuthenticationChallengeBlocked { false };
241     ResourceRequest m_deferredRequest;
242     ResourceLoaderOptions m_options;
243
244 #if ENABLE(CONTENT_EXTENSIONS)
245 protected:
246     ResourceType m_resourceType { ResourceType::Invalid };
247 #endif
248 };
249
250 } // namespace WebCore