2008-04-17 Anders Carlsson <andersca@apple.com>
[WebKit-https.git] / WebCore / loader / DocumentLoader.h
1 /*
2  * Copyright (C) 2006, 2007 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 DocumentLoader_h
30 #define DocumentLoader_h
31
32 #include "IconDatabase.h"
33 #include "NavigationAction.h"
34 #include <wtf/RefCounted.h>
35 #include "PlatformString.h"
36 #include "ResourceError.h"
37 #include "ResourceRequest.h"
38 #include "ResourceResponse.h"
39 #include "SubstituteData.h"
40 #include <wtf/HashSet.h>
41 #include <wtf/RefPtr.h>
42 #include <wtf/Vector.h>
43
44 namespace WebCore {
45
46 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
47     class ApplicationCache;
48     class ApplicationCacheGroup;
49 #endif
50     class Archive;
51     class ArchiveResource;
52     class ArchiveResourceCollection;
53     class CachedPage;
54     class Frame;
55     class FrameLoader;
56     class HistoryItem;
57     class KURL;
58     class MainResourceLoader;
59     class ResourceLoader;
60     class SchedulePair;
61     class SharedBuffer;
62     class SubstituteData;
63     class SubstituteResource;
64
65     typedef HashSet<RefPtr<ResourceLoader> > ResourceLoaderSet;
66     typedef Vector<ResourceResponse> ResponseVector;
67
68     class DocumentLoader : public RefCounted<DocumentLoader> {
69     public:
70         DocumentLoader(const ResourceRequest&, const SubstituteData&);
71         virtual ~DocumentLoader();
72
73         void setFrame(Frame*);
74         Frame* frame() const { return m_frame; }
75
76         virtual void attachToFrame();
77         virtual void detachFromFrame();
78
79         FrameLoader* frameLoader() const;
80         MainResourceLoader* mainResourceLoader() const { return m_mainResourceLoader.get(); }
81         PassRefPtr<SharedBuffer> mainResourceData() const;
82
83         const ResourceRequest& originalRequest() const;
84         const ResourceRequest& originalRequestCopy() const;
85
86         const ResourceRequest& request() const;
87         ResourceRequest& request();
88         void setRequest(const ResourceRequest&);
89
90         const SubstituteData& substituteData() const { return m_substituteData; }
91
92         const KURL& url() const;
93         const KURL& unreachableURL() const;
94
95         const KURL& originalURL() const;
96         const KURL& requestURL() const;
97         const KURL& responseURL() const;
98         const String& responseMIMEType() const;
99         
100         void replaceRequestURLForAnchorScroll(const KURL&);
101         bool isStopping() const { return m_isStopping; }
102         void stopLoading();
103         void setCommitted(bool committed) { m_committed = committed; }
104         bool isCommitted() const { return m_committed; }
105         bool isLoading() const { return m_loading; }
106         void setLoading(bool loading) { m_loading = loading; }
107         void updateLoading();
108         void receivedData(const char*, int);
109         void setupForReplaceByMIMEType(const String& newMIMEType);
110         void finishedLoading();
111         const ResourceResponse& response() const { return m_response; }
112         const ResourceError& mainDocumentError() const { return m_mainDocumentError; }
113         void mainReceivedError(const ResourceError&, bool isComplete);
114         void setResponse(const ResourceResponse& response) { m_response = response; }
115         void prepareForLoadStart();
116         bool isClientRedirect() const { return m_isClientRedirect; }
117         void setIsClientRedirect(bool isClientRedirect) { m_isClientRedirect = isClientRedirect; }
118         bool isLoadingInAPISense() const;
119         void setPrimaryLoadComplete(bool);
120         void setTitle(const String&);
121         const String& overrideEncoding() const { return m_overrideEncoding; }
122
123 #if PLATFORM(MAC)
124         void schedule(SchedulePair*);
125         void unschedule(SchedulePair*);
126 #endif
127
128         void addAllArchiveResources(Archive*);
129         void addArchiveResource(PassRefPtr<ArchiveResource>);
130         
131         // Return an ArchiveResource for the URL, either creating from live data or
132         // pulling from the ArchiveResourceCollection
133         PassRefPtr<ArchiveResource> subresource(const KURL&) const;
134         // Return the ArchiveResource for the URL only when loading an Archive
135         ArchiveResource* archiveResourceForURL(const KURL&) const;
136         
137         PassRefPtr<Archive> popArchiveForSubframe(const String& frameName);
138         void clearArchiveResources();
139         void setParsedArchiveData(PassRefPtr<SharedBuffer>);
140         SharedBuffer* parsedArchiveData() const;
141         
142         PassRefPtr<ArchiveResource> mainResource() const;
143         void getSubresources(Vector<PassRefPtr<ArchiveResource> >&) const;
144         
145         bool scheduleArchiveLoad(ResourceLoader*, const ResourceRequest&, const KURL&);
146 #ifndef NDEBUG
147         bool isSubstituteLoadPending(ResourceLoader*) const;
148 #endif
149         void cancelPendingSubstituteLoad(ResourceLoader*);   
150         
151         void addResponse(const ResourceResponse&);
152         const ResponseVector& responses() const { return m_responses; }
153
154         const NavigationAction& triggeringAction() const { return m_triggeringAction; }
155         void setTriggeringAction(const NavigationAction& action) { m_triggeringAction = action; }
156         void setOverrideEncoding(const String& encoding) { m_overrideEncoding = encoding; }
157         void setLastCheckedRequest(const ResourceRequest& request) { m_lastCheckedRequest = request; }
158         const ResourceRequest& lastCheckedRequest()  { return m_lastCheckedRequest; }
159
160         void stopRecordingResponses();
161         const String& title() const { return m_pageTitle; }
162         KURL urlForHistory() const;
163         
164         void loadFromCachedPage(PassRefPtr<CachedPage>);
165         void setLoadingFromCachedPage(bool loading) { m_loadingFromCachedPage = loading; }
166         bool isLoadingFromCachedPage() const { return m_loadingFromCachedPage; }
167         
168         void setDefersLoading(bool);
169
170         bool startLoadingMainResource(unsigned long identifier);
171         void cancelMainResourceLoad(const ResourceError&);
172         
173         void iconLoadDecisionAvailable();
174         
175         bool isLoadingMainResource() const;
176         bool isLoadingSubresources() const;
177         bool isLoadingPlugIns() const;
178         bool isLoadingMultipartContent() const;
179
180         void stopLoadingPlugIns();
181         void stopLoadingSubresources();
182
183         void addSubresourceLoader(ResourceLoader*);
184         void removeSubresourceLoader(ResourceLoader*);
185         void addPlugInStreamLoader(ResourceLoader*);
186         void removePlugInStreamLoader(ResourceLoader*);
187
188         void subresourceLoaderFinishedLoadingOnePart(ResourceLoader*);
189         
190         bool deferMainResourceDataLoad() const { return m_deferMainResourceDataLoad; }
191         
192 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
193         void setCandidateApplicationCacheGroup(ApplicationCacheGroup* group);
194         ApplicationCacheGroup* candidateApplicationCacheGroup() const { return m_candidateApplicationCacheGroup; }
195         
196         void setApplicationCache(PassRefPtr<ApplicationCache> applicationCache);
197         ApplicationCache* applicationCache() const { return m_applicationCache.get(); }
198         ApplicationCache* toplevelApplicationCache() const;
199 #endif
200         
201     protected:
202         bool m_deferMainResourceDataLoad;
203
204     private:
205         void setupForReplace();
206         void commitIfReady();
207         void clearErrors();
208         void setMainDocumentError(const ResourceError&);
209         void commitLoad(const char*, int);
210         bool doesProgressiveLoad(const String& MIMEType) const;
211
212         void deliverSubstituteResourcesAfterDelay();
213         void substituteResourceDeliveryTimerFired(Timer<DocumentLoader>*);
214                 
215         Frame* m_frame;
216
217         RefPtr<MainResourceLoader> m_mainResourceLoader;
218         ResourceLoaderSet m_subresourceLoaders;
219         ResourceLoaderSet m_multipartSubresourceLoaders;
220         ResourceLoaderSet m_plugInStreamLoaders;
221
222         RefPtr<SharedBuffer> m_mainResourceData;
223
224         // A reference to actual request used to create the data source.
225         // This should only be used by the resourceLoadDelegate's
226         // identifierForInitialRequest:fromDatasource: method. It is
227         // not guaranteed to remain unchanged, as requests are mutable.
228         ResourceRequest m_originalRequest;   
229
230         SubstituteData m_substituteData;
231
232         // A copy of the original request used to create the data source.
233         // We have to copy the request because requests are mutable.
234         ResourceRequest m_originalRequestCopy;
235         
236         // The 'working' request. It may be mutated
237         // several times from the original request to include additional
238         // headers, cookie information, canonicalization and redirects.
239         ResourceRequest m_request;
240
241         mutable ResourceRequest m_externalRequest;
242
243         ResourceResponse m_response;
244     
245         ResourceError m_mainDocumentError;    
246
247         bool m_committed;
248         bool m_isStopping;
249         bool m_loading;
250         bool m_gotFirstByte;
251         bool m_primaryLoadComplete;
252         bool m_isClientRedirect;
253         bool m_loadingFromCachedPage;
254
255         String m_pageTitle;
256
257         String m_overrideEncoding;
258
259         // The action that triggered loading - we keep this around for the
260         // benefit of the various policy handlers.
261         NavigationAction m_triggeringAction;
262
263         // The last request that we checked click policy for - kept around
264         // so we can avoid asking again needlessly.
265         ResourceRequest m_lastCheckedRequest;
266
267         // We retain all the received responses so we can play back the
268         // WebResourceLoadDelegate messages if the item is loaded from the
269         // page cache.
270         ResponseVector m_responses;
271         bool m_stopRecordingResponses;
272         
273         typedef HashMap<RefPtr<ResourceLoader>, RefPtr<SubstituteResource> > SubstituteResourceMap;
274         SubstituteResourceMap m_pendingSubstituteResources;
275         Timer<DocumentLoader> m_substituteResourceDeliveryTimer;
276                 
277         OwnPtr<ArchiveResourceCollection> m_archiveResourceCollection;
278         RefPtr<SharedBuffer> m_parsedArchiveData;
279         
280 #if ENABLE(OFFLINE_WEB_APPLICATIONS)  
281         // The application cache that the document loader is associated with (if any).
282         RefPtr<ApplicationCache> m_applicationCache;
283         
284         // Before an application cache has finished loading, this will be the candidate application
285         // group that the document loader is associated with.
286         ApplicationCacheGroup* m_candidateApplicationCacheGroup;
287 #endif
288     };
289
290 }
291
292 #endif // DocumentLoader_h