Remove "virtual" from all lines that have both "virtual" and "override".
[WebKit-https.git] / Source / WebCore / loader / ResourceLoader.h
1 /*
2  * Copyright (C) 2005, 2006, 2011 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 #ifndef ResourceLoader_h
30 #define ResourceLoader_h
31
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 namespace WTF {
40 class SchedulePair;
41 }
42
43 namespace WebCore {
44
45 class AuthenticationChallenge;
46 class DocumentLoader;
47 class Frame;
48 class FrameLoader;
49 class URL;
50
51 #if USE(QUICK_LOOK)
52 class QuickLookHandle;
53 #endif
54
55 #if ENABLE(CONTENT_EXTENSIONS)
56 enum class ResourceType : uint16_t;
57 #endif
58
59 class ResourceLoader : public RefCounted<ResourceLoader>, protected ResourceHandleClient {
60 public:
61     virtual ~ResourceLoader() = 0;
62
63     WEBCORE_EXPORT void cancel();
64
65     virtual bool init(const ResourceRequest&);
66
67     void deliverResponseAndData(const ResourceResponse&, RefPtr<SharedBuffer>&&);
68
69 #if PLATFORM(IOS)
70     virtual bool startLoading()
71     {
72         start();
73         return true;
74     }
75
76     virtual const ResourceRequest& iOSOriginalRequest() const { return request(); }
77 #endif
78
79     WEBCORE_EXPORT FrameLoader* frameLoader() const;
80     DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
81     const ResourceRequest& originalRequest() const { return m_originalRequest; }
82
83     WEBCORE_EXPORT void start();
84     WEBCORE_EXPORT void cancel(const ResourceError&);
85     WEBCORE_EXPORT ResourceError cancelledError();
86     ResourceError blockedError();
87     ResourceError cannotShowURLError();
88     
89     virtual void setDefersLoading(bool);
90     bool defersLoading() const { return m_defersLoading; }
91
92     unsigned long identifier() const { return m_identifier; }
93
94     virtual void releaseResources();
95     const ResourceResponse& response() const;
96
97     SharedBuffer* resourceData() const { return m_resourceData.get(); }
98     void clearResourceData();
99     
100     virtual bool isSubresourceLoader();
101
102     virtual void willSendRequest(ResourceRequest&&, const ResourceResponse& redirectResponse, std::function<void(ResourceRequest&&)>&& callback);
103     virtual void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent);
104     virtual void didReceiveResponse(const ResourceResponse&);
105     virtual void didReceiveData(const char*, unsigned, long long encodedDataLength, DataPayloadType);
106     virtual void didReceiveBuffer(PassRefPtr<SharedBuffer>, long long encodedDataLength, DataPayloadType);
107     virtual void didFinishLoading(double finishTime);
108     virtual void didFail(const ResourceError&);
109 #if USE(NETWORK_CFDATA_ARRAY_CALLBACK)
110     virtual void didReceiveDataArray(CFArrayRef dataArray);
111 #endif
112
113     virtual bool shouldUseCredentialStorage();
114     virtual void didReceiveAuthenticationChallenge(const AuthenticationChallenge&);
115     WEBCORE_EXPORT void didCancelAuthenticationChallenge(const AuthenticationChallenge&);
116 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
117     virtual bool canAuthenticateAgainstProtectionSpace(const ProtectionSpace&);
118 #endif
119     virtual void receivedCancellation(const AuthenticationChallenge&);
120
121 #if USE(QUICK_LOOK)
122     void didCreateQuickLookHandle(QuickLookHandle&) override;
123 #endif
124     bool isQuickLookResource() { return m_isQuickLookResource; }
125
126     const URL& url() const { return m_request.url(); }
127     ResourceHandle* handle() const { return m_handle.get(); }
128     bool shouldSendResourceLoadCallbacks() const { return m_options.sendLoadCallbacks() == SendCallbacks; }
129     void setSendCallbackPolicy(SendCallbackPolicy sendLoadCallbacks) { m_options.setSendLoadCallbacks(sendLoadCallbacks); }
130     bool shouldSniffContent() const { return m_options.sniffContent() == SniffContent; }
131     WEBCORE_EXPORT bool isAllowedToAskUserForCredentials() const;
132     bool shouldIncludeCertificateInfo() const { return m_options.certificateInfoPolicy() == IncludeCertificateInfo; }
133
134     bool reachedTerminalState() const { return m_reachedTerminalState; }
135
136
137     const ResourceRequest& request() const { return m_request; }
138
139     void setDataBufferingPolicy(DataBufferingPolicy);
140
141     void willSwitchToSubstituteResource();
142
143 #if PLATFORM(COCOA) && !USE(CFNETWORK)
144     void schedule(WTF::SchedulePair&);
145     void unschedule(WTF::SchedulePair&);
146 #endif
147
148 protected:
149     ResourceLoader(Frame*, ResourceLoaderOptions);
150
151     void didFinishLoadingOnePart(double finishTime);
152     void cleanupForError(const ResourceError&);
153
154     bool wasCancelled() const { return m_cancellationStatus >= Cancelled; }
155
156     void didReceiveDataOrBuffer(const char*, unsigned, PassRefPtr<SharedBuffer>, long long encodedDataLength, DataPayloadType);
157
158     const ResourceLoaderOptions& options() { return m_options; }
159
160 #if PLATFORM(COCOA) && !USE(CFNETWORK)
161     NSCachedURLResponse* willCacheResponse(ResourceHandle*, NSCachedURLResponse*) override;
162 #endif
163 #if PLATFORM(COCOA) && USE(CFNETWORK)
164     CFCachedURLResponseRef willCacheResponse(ResourceHandle*, CFCachedURLResponseRef) override;
165 #endif
166
167     virtual void willSendRequestInternal(ResourceRequest&, const ResourceResponse& redirectResponse);
168
169     RefPtr<ResourceHandle> m_handle;
170     RefPtr<Frame> m_frame;
171     RefPtr<DocumentLoader> m_documentLoader;
172     ResourceResponse m_response;
173     
174 private:
175     virtual void willCancel(const ResourceError&) = 0;
176     virtual void didCancel(const ResourceError&) = 0;
177
178     void addDataOrBuffer(const char*, unsigned, SharedBuffer*, DataPayloadType);
179     void loadDataURL();
180     void finishNetworkLoad();
181
182     // ResourceHandleClient
183     void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse& redirectResponse) override;
184     void didSendData(ResourceHandle*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
185     void didReceiveResponse(ResourceHandle*, const ResourceResponse&) override;
186     void didReceiveData(ResourceHandle*, const char*, unsigned, int encodedDataLength) override;
187     void didReceiveBuffer(ResourceHandle*, PassRefPtr<SharedBuffer>, int encodedDataLength) override;
188     void didFinishLoading(ResourceHandle*, double finishTime) override;
189     void didFail(ResourceHandle*, const ResourceError&) override;
190     void wasBlocked(ResourceHandle*) override;
191     void cannotShowURL(ResourceHandle*) override;
192 #if USE(NETWORK_CFDATA_ARRAY_CALLBACK)
193     void didReceiveDataArray(ResourceHandle*, CFArrayRef dataArray) override;
194 #endif
195     bool shouldUseCredentialStorage(ResourceHandle*) override { return shouldUseCredentialStorage(); }
196     void didReceiveAuthenticationChallenge(ResourceHandle*, const AuthenticationChallenge& challenge) override { didReceiveAuthenticationChallenge(challenge); } 
197     void didCancelAuthenticationChallenge(ResourceHandle*, const AuthenticationChallenge& challenge) override { didCancelAuthenticationChallenge(challenge); } 
198 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
199     bool canAuthenticateAgainstProtectionSpace(ResourceHandle*, const ProtectionSpace& protectionSpace) override { return canAuthenticateAgainstProtectionSpace(protectionSpace); }
200 #endif
201     void receivedCancellation(ResourceHandle*, const AuthenticationChallenge& challenge) override { receivedCancellation(challenge); }
202 #if PLATFORM(IOS)
203     RetainPtr<CFDictionaryRef> connectionProperties(ResourceHandle*) override;
204 #endif
205 #if PLATFORM(WIN) && USE(CFNETWORK)
206     // FIXME: Windows should use willCacheResponse - <https://bugs.webkit.org/show_bug.cgi?id=57257>.
207     bool shouldCacheResponse(ResourceHandle*, CFCachedURLResponseRef) override;
208 #endif
209
210     ResourceRequest m_request;
211     ResourceRequest m_originalRequest; // Before redirects.
212     RefPtr<SharedBuffer> m_resourceData;
213     
214     unsigned long m_identifier;
215
216     bool m_reachedTerminalState;
217     bool m_notifiedLoadComplete;
218
219     enum CancellationStatus {
220         NotCancelled,
221         CalledWillCancel,
222         Cancelled,
223         FinishedCancel
224     };
225     CancellationStatus m_cancellationStatus;
226
227     bool m_defersLoading;
228     ResourceRequest m_deferredRequest;
229     ResourceLoaderOptions m_options;
230     bool m_isQuickLookResource;
231
232 #if ENABLE(CONTENT_EXTENSIONS)
233 protected:
234     ResourceType m_resourceType;
235 #endif
236 };
237
238 inline const ResourceResponse& ResourceLoader::response() const
239 {
240     return m_response;
241 }
242
243 }
244
245 #endif