a89fac06106f6b1bf6521535028e63f6eb645d7f
[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 Computer, 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 "ResourceRequest.h"
35 #include "ResourceResponse.h"
36
37 #include <wtf/Forward.h>
38 #include <wtf/RefCounted.h>
39
40 namespace WebCore {
41
42 class AuthenticationChallenge;
43 class DocumentLoader;
44 class Frame;
45 class FrameLoader;
46 class KURL;
47 class ResourceBuffer;
48 class ResourceHandle;
49
50 class ResourceLoader : public RefCounted<ResourceLoader>, protected ResourceHandleClient {
51 public:
52     virtual ~ResourceLoader();
53
54     void cancel();
55
56     virtual bool init(const ResourceRequest&);
57
58     FrameLoader* frameLoader() const;
59     DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
60     const ResourceRequest& originalRequest() const { return m_originalRequest; }
61     
62     virtual void cancel(const ResourceError&);
63     ResourceError cancelledError();
64     ResourceError blockedError();
65     ResourceError cannotShowURLError();
66     
67     virtual void setDefersLoading(bool);
68     bool defersLoading() const { return m_defersLoading; }
69
70     unsigned long identifier() const { return m_identifier; }
71
72     virtual void releaseResources();
73     const ResourceResponse& response() const;
74
75     virtual void addData(const char*, int, bool allAtOnce);
76     virtual PassRefPtr<ResourceBuffer> resourceData();
77     void clearResourceData();
78     virtual bool isSubresourceLoader();
79     
80     virtual void willSendRequest(ResourceRequest&, const ResourceResponse& redirectResponse);
81     virtual void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent);
82     virtual void didReceiveResponse(const ResourceResponse&);
83     virtual void didReceiveData(const char*, int, long long encodedDataLength, bool allAtOnce);
84     virtual void didReceiveCachedMetadata(const char*, int) { }
85     void willStopBufferingData(const char*, int);
86     virtual void didFinishLoading(double finishTime);
87     virtual void didFail(const ResourceError&);
88 #if USE(NETWORK_CFDATA_ARRAY_CALLBACK)
89     virtual void didReceiveDataArray(CFArrayRef dataArray);
90 #endif
91     void didChangePriority(ResourceLoadPriority);
92
93     virtual bool shouldUseCredentialStorage();
94     virtual void didReceiveAuthenticationChallenge(const AuthenticationChallenge&);
95     void didCancelAuthenticationChallenge(const AuthenticationChallenge&);
96 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
97     virtual bool canAuthenticateAgainstProtectionSpace(const ProtectionSpace&);
98 #endif
99     virtual void receivedCancellation(const AuthenticationChallenge&);
100
101     // ResourceHandleClient
102     virtual void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse& redirectResponse);
103     virtual void didSendData(ResourceHandle*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent);
104     virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);
105     virtual void didReceiveData(ResourceHandle*, const char*, int, int encodedDataLength);
106     virtual void didReceiveCachedMetadata(ResourceHandle*, const char* data, int length) { didReceiveCachedMetadata(data, length); }
107     virtual void didFinishLoading(ResourceHandle*, double finishTime);
108     virtual void didFail(ResourceHandle*, const ResourceError&);
109     virtual void wasBlocked(ResourceHandle*);
110     virtual void cannotShowURL(ResourceHandle*);
111     virtual void willStopBufferingData(ResourceHandle*, const char* data, int length) { willStopBufferingData(data, length); } 
112     virtual bool shouldUseCredentialStorage(ResourceHandle*) { return shouldUseCredentialStorage(); }
113     virtual void didReceiveAuthenticationChallenge(ResourceHandle*, const AuthenticationChallenge& challenge) { didReceiveAuthenticationChallenge(challenge); } 
114     virtual void didCancelAuthenticationChallenge(ResourceHandle*, const AuthenticationChallenge& challenge) { didCancelAuthenticationChallenge(challenge); } 
115 #if USE(NETWORK_CFDATA_ARRAY_CALLBACK)
116     virtual void didReceiveDataArray(ResourceHandle*, CFArrayRef dataArray);
117 #endif
118 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
119     virtual bool canAuthenticateAgainstProtectionSpace(ResourceHandle*, const ProtectionSpace& protectionSpace) { return canAuthenticateAgainstProtectionSpace(protectionSpace); }
120 #endif
121     virtual void receivedCancellation(ResourceHandle*, const AuthenticationChallenge& challenge) { receivedCancellation(challenge); }
122 #if PLATFORM(MAC)
123 #if USE(CFNETWORK)
124     virtual CFCachedURLResponseRef willCacheResponse(ResourceHandle*, CFCachedURLResponseRef);
125 #else
126     virtual NSCachedURLResponse* willCacheResponse(ResourceHandle*, NSCachedURLResponse*);
127 #endif
128 #endif // PLATFORM(MAC)
129 #if PLATFORM(WIN) && USE(CFNETWORK)
130     // FIXME: Windows should use willCacheResponse - <https://bugs.webkit.org/show_bug.cgi?id=57257>.
131     virtual bool shouldCacheResponse(ResourceHandle*, CFCachedURLResponseRef);
132 #endif
133 #if PLATFORM(CHROMIUM)
134     virtual void didDownloadData(ResourceHandle*, int);
135     virtual void didDownloadData(int);
136 #endif
137
138     const KURL& url() const { return m_request.url(); } 
139     ResourceHandle* handle() const { return m_handle.get(); }
140     bool shouldSendResourceLoadCallbacks() const { return m_options.sendLoadCallbacks == SendCallbacks; }
141     void setSendCallbackPolicy(SendCallbackPolicy sendLoadCallbacks) { m_options.sendLoadCallbacks = sendLoadCallbacks; }
142     bool shouldSniffContent() const { return m_options.sniffContent == SniffContent; }
143
144     bool reachedTerminalState() const { return m_reachedTerminalState; }
145
146     const ResourceRequest& request() const { return m_request; }
147
148     void setDataBufferingPolicy(DataBufferingPolicy);
149
150     virtual void reportMemoryUsage(MemoryObjectInfo*) const;
151
152 protected:
153     ResourceLoader(Frame*, ResourceLoaderOptions);
154
155     friend class ResourceLoadScheduler; // for access to start()
156     // start() actually sends the load to the network (unless the load is being
157     // deferred) and should only be called by ResourceLoadScheduler or setDefersLoading().
158     void start();
159
160     void didFinishLoadingOnePart(double finishTime);
161
162     bool cancelled() const { return m_cancelled; }
163
164     RefPtr<ResourceHandle> m_handle;
165     RefPtr<Frame> m_frame;
166     RefPtr<DocumentLoader> m_documentLoader;
167     ResourceResponse m_response;
168     
169 private:
170     virtual void willCancel(const ResourceError&) = 0;
171     virtual void didCancel(const ResourceError&) = 0;
172
173     ResourceRequest m_request;
174     ResourceRequest m_originalRequest; // Before redirects.
175     RefPtr<ResourceBuffer> m_resourceData;
176     
177     unsigned long m_identifier;
178
179     bool m_reachedTerminalState;
180     bool m_calledWillCancel;
181     bool m_cancelled;
182     bool m_notifiedLoadComplete;
183
184     bool m_defersLoading;
185     ResourceRequest m_deferredRequest;
186     ResourceLoaderOptions m_options;
187 };
188
189 inline const ResourceResponse& ResourceLoader::response() const
190 {
191     return m_response;
192 }
193
194 }
195
196 #endif