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