42c54a13948b1a08c6e75f1772997df16806b5ab
[WebKit-https.git] / Source / WebCore / loader / DocumentLoader.h
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
3  * Copyright (C) 2011 Google Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer. 
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution. 
14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission. 
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #ifndef DocumentLoader_h
31 #define DocumentLoader_h
32
33 #include "DocumentLoadTiming.h"
34 #include "DocumentWriter.h"
35 #include "IconDatabaseBase.h"
36 #include "NavigationAction.h"
37 #include "ResourceError.h"
38 #include "ResourceLoaderOptions.h"
39 #include "ResourceRequest.h"
40 #include "ResourceResponse.h"
41 #include "StringWithDirection.h"
42 #include "SubstituteData.h"
43 #include "Timer.h"
44 #include <wtf/HashSet.h>
45 #include <wtf/RefPtr.h>
46 #include <wtf/Vector.h>
47
48 namespace WTF {
49 class SchedulePair;
50 }
51
52 namespace WebCore {
53     class ApplicationCacheHost;
54 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
55     class Archive;
56 #endif
57     class ArchiveResource;
58     class ArchiveResourceCollection;
59     class CachedResourceLoader;
60     class ContentFilter;
61     class FormState;
62     class Frame;
63     class FrameLoader;
64     class MainResourceLoader;
65     class Page;
66     class ResourceBuffer;
67     class ResourceLoader;
68     class SharedBuffer;
69     class SubstituteResource;
70
71     typedef HashSet<RefPtr<ResourceLoader> > ResourceLoaderSet;
72     typedef Vector<ResourceResponse> ResponseVector;
73
74     class DocumentLoader : public RefCounted<DocumentLoader> {
75     public:
76         static PassRefPtr<DocumentLoader> create(const ResourceRequest& request, const SubstituteData& data)
77         {
78             return adoptRef(new DocumentLoader(request, data));
79         }
80         virtual ~DocumentLoader();
81
82         void setFrame(Frame*);
83         Frame* frame() const { return m_frame; }
84
85         virtual void attachToFrame();
86         virtual void detachFromFrame();
87
88         FrameLoader* frameLoader() const;
89         ResourceLoader* mainResourceLoader() const;
90         PassRefPtr<ResourceBuffer> mainResourceData() const;
91         
92         DocumentWriter* writer() const { return &m_writer; }
93         Document* document() const;
94
95         const ResourceRequest& originalRequest() const;
96         const ResourceRequest& originalRequestCopy() const;
97
98         const ResourceRequest& request() const;
99         ResourceRequest& request();
100         void setRequest(const ResourceRequest&);
101
102         CachedResourceLoader* cachedResourceLoader() const { return m_cachedResourceLoader.get(); }
103
104         const SubstituteData& substituteData() const { return m_substituteData; }
105
106         // FIXME: This is the same as requestURL(). We should remove one of them.
107         const KURL& url() const;
108         const KURL& unreachableURL() const;
109
110         // The URL of the document resulting from this DocumentLoader.
111         KURL documentURL() const;
112
113         const KURL& originalURL() const;
114         const KURL& requestURL() const;
115         const KURL& responseURL() const;
116         const String& responseMIMEType() const;
117
118         void replaceRequestURLForSameDocumentNavigation(const KURL&);
119         bool isStopping() const { return m_isStopping; }
120         void stopLoading();
121         void setCommitted(bool committed) { m_committed = committed; }
122         bool isCommitted() const { return m_committed; }
123         bool isLoading() const;
124         void receivedData(const char*, int);
125         void setupForReplace();
126         void finishedLoading(double finishTime);
127         const ResourceResponse& response() const { return m_response; }
128         const ResourceError& mainDocumentError() const { return m_mainDocumentError; }
129         void mainReceivedError(const ResourceError&);
130         void setResponse(const ResourceResponse& response) { m_response = response; }
131         bool isClientRedirect() const { return m_isClientRedirect; }
132         void setIsClientRedirect(bool isClientRedirect) { m_isClientRedirect = isClientRedirect; }
133         void handledOnloadEvents();
134         bool wasOnloadHandled() { return m_wasOnloadHandled; }
135         bool isLoadingInAPISense() const;
136         void setTitle(const StringWithDirection&);
137         const String& overrideEncoding() const { return m_overrideEncoding; }
138
139 #if PLATFORM(MAC)
140         void schedule(WTF::SchedulePair*);
141         void unschedule(WTF::SchedulePair*);
142 #endif
143
144 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
145         void setArchive(PassRefPtr<Archive>);
146         void addAllArchiveResources(Archive*);
147         void addArchiveResource(PassRefPtr<ArchiveResource>);
148         PassRefPtr<Archive> popArchiveForSubframe(const String& frameName, const KURL&);
149         SharedBuffer* parsedArchiveData() const;
150
151         bool scheduleArchiveLoad(ResourceLoader*, const ResourceRequest&);
152 #endif // ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
153
154         // Return the ArchiveResource for the URL only when loading an Archive
155         ArchiveResource* archiveResourceForURL(const KURL&) const;
156
157         PassRefPtr<ArchiveResource> mainResource() const;
158
159         // Return an ArchiveResource for the URL, either creating from live data or
160         // pulling from the ArchiveResourceCollection
161         PassRefPtr<ArchiveResource> subresource(const KURL&) const;
162         void getSubresources(Vector<PassRefPtr<ArchiveResource> >&) const;
163
164
165 #ifndef NDEBUG
166         bool isSubstituteLoadPending(ResourceLoader*) const;
167 #endif
168         void cancelPendingSubstituteLoad(ResourceLoader*);   
169         
170         void addResponse(const ResourceResponse&);
171         const ResponseVector& responses() const { return m_responses; }
172
173         const NavigationAction& triggeringAction() const { return m_triggeringAction; }
174         void setTriggeringAction(const NavigationAction& action) { m_triggeringAction = action; }
175         void setOverrideEncoding(const String& encoding) { m_overrideEncoding = encoding; }
176         void setLastCheckedRequest(const ResourceRequest& request) { m_lastCheckedRequest = request; }
177         const ResourceRequest& lastCheckedRequest()  { return m_lastCheckedRequest; }
178
179         void stopRecordingResponses();
180         const StringWithDirection& title() const { return m_pageTitle; }
181
182         KURL urlForHistory() const;
183         bool urlForHistoryReflectsFailure() const;
184
185         // These accessors accommodate WebCore's somewhat fickle custom of creating history
186         // items for redirects, but only sometimes. For "source" and "destination",
187         // these accessors return the URL that would have been used if a history
188         // item were created. This allows WebKit to link history items reflecting
189         // redirects into a chain from start to finish.
190         String clientRedirectSourceForHistory() const { return m_clientRedirectSourceForHistory; } // null if no client redirect occurred.
191         String clientRedirectDestinationForHistory() const { return urlForHistory(); }
192         void setClientRedirectSourceForHistory(const String& clientRedirectSourceForHistory) { m_clientRedirectSourceForHistory = clientRedirectSourceForHistory; }
193         
194         String serverRedirectSourceForHistory() const { return (urlForHistory() == url() || url() == blankURL()) ? String() : urlForHistory().string(); } // null if no server redirect occurred.
195         String serverRedirectDestinationForHistory() const { return url(); }
196
197         bool didCreateGlobalHistoryEntry() const { return m_didCreateGlobalHistoryEntry; }
198         void setDidCreateGlobalHistoryEntry(bool didCreateGlobalHistoryEntry) { m_didCreateGlobalHistoryEntry = didCreateGlobalHistoryEntry; }
199         
200         void setDefersLoading(bool);
201         void setMainResourceDataBufferingPolicy(DataBufferingPolicy);
202
203         void startLoadingMainResource();
204         void cancelMainResourceLoad(const ResourceError&);
205         
206         // Support iconDatabase in synchronous mode.
207         void iconLoadDecisionAvailable();
208         
209         // Support iconDatabase in asynchronous mode.
210         void continueIconLoadWithDecision(IconLoadDecision);
211         void getIconLoadDecisionForIconURL(const String&);
212         void getIconDataForIconURL(const String&);
213         
214         bool isLoadingMainResource() const;
215         bool isLoadingMultipartContent() const { return m_isLoadingMultipartContent; }
216
217         void stopLoadingPlugIns();
218         void stopLoadingSubresources();
219
220         void addSubresourceLoader(ResourceLoader*);
221         void removeSubresourceLoader(ResourceLoader*);
222         void addPlugInStreamLoader(ResourceLoader*);
223         void removePlugInStreamLoader(ResourceLoader*);
224
225         void subresourceLoaderFinishedLoadingOnePart(ResourceLoader*);
226
227         void maybeFinishLoadingMultipartContent();
228
229         void setDeferMainResourceDataLoad(bool defer) { m_deferMainResourceDataLoad = defer; }
230         bool deferMainResourceDataLoad() const { return m_deferMainResourceDataLoad; }
231         
232         void didTellClientAboutLoad(const String& url)
233         { 
234 #if !PLATFORM(MAC)
235             // Don't include data urls here, as if a lot of data is loaded
236             // that way, we hold on to the (large) url string for too long.
237             if (protocolIs(url, "data"))
238                 return;
239 #endif
240             if (!url.isEmpty())
241                 m_resourcesClientKnowsAbout.add(url);
242         }
243         bool haveToldClientAboutLoad(const String& url) { return m_resourcesClientKnowsAbout.contains(url); }
244         void recordMemoryCacheLoadForFutureClientNotification(const ResourceRequest&);
245         void takeMemoryCacheLoadsForClientNotification(Vector<ResourceRequest>& loads);
246
247         DocumentLoadTiming* timing() { return &m_documentLoadTiming; }
248         void resetTiming() { m_documentLoadTiming = DocumentLoadTiming(); }
249
250         void responseReceived(const ResourceResponse&);
251
252         // The WebKit layer calls this function when it's ready for the data to
253         // actually be added to the document.
254         void commitData(const char* bytes, size_t length);
255
256         ApplicationCacheHost* applicationCacheHost() const { return m_applicationCacheHost.get(); }
257
258         virtual void reportMemoryUsage(MemoryObjectInfo*) const;
259         void checkLoadComplete();
260
261         // FIXME: This should be private once DocumentLoader and MainResourceLoader are merged.
262         void willSendRequest(ResourceRequest&, const ResourceResponse&);
263
264     protected:
265         DocumentLoader(const ResourceRequest&, const SubstituteData&);
266
267         bool m_deferMainResourceDataLoad;
268
269     private:
270         void commitIfReady();
271         void setMainDocumentError(const ResourceError&);
272         void commitLoad(const char*, int);
273         void clearMainResourceLoader();
274         
275         bool maybeCreateArchive();
276 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
277         void clearArchiveResources();
278 #endif
279
280         bool maybeLoadEmpty();
281
282         bool isMultipartReplacingLoad() const;
283         bool isPostOrRedirectAfterPost(const ResourceRequest&, const ResourceResponse&);
284
285         static void callContinueAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
286         void continueAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
287
288         static void callContinueAfterContentPolicy(void*, PolicyAction);
289         void continueAfterContentPolicy(PolicyAction);
290
291         void stopLoadingForPolicyChange();
292         ResourceError interruptedForPolicyChangeError() const;
293
294         void deliverSubstituteResourcesAfterDelay();
295         void substituteResourceDeliveryTimerFired(Timer<DocumentLoader>*);
296                 
297         Frame* m_frame;
298         RefPtr<CachedResourceLoader> m_cachedResourceLoader;
299
300         RefPtr<MainResourceLoader> m_mainResourceLoader;
301         ResourceLoaderSet m_subresourceLoaders;
302         ResourceLoaderSet m_multipartSubresourceLoaders;
303         ResourceLoaderSet m_plugInStreamLoaders;
304
305         RefPtr<ResourceBuffer> m_mainResourceData;
306         
307         mutable DocumentWriter m_writer;
308
309         // A reference to actual request used to create the data source.
310         // This should only be used by the resourceLoadDelegate's
311         // identifierForInitialRequest:fromDatasource: method. It is
312         // not guaranteed to remain unchanged, as requests are mutable.
313         ResourceRequest m_originalRequest;   
314
315         SubstituteData m_substituteData;
316
317         // A copy of the original request used to create the data source.
318         // We have to copy the request because requests are mutable.
319         ResourceRequest m_originalRequestCopy;
320         
321         // The 'working' request. It may be mutated
322         // several times from the original request to include additional
323         // headers, cookie information, canonicalization and redirects.
324         ResourceRequest m_request;
325
326         ResourceResponse m_response;
327     
328         ResourceError m_mainDocumentError;    
329
330         bool m_committed;
331         bool m_isStopping;
332         bool m_gotFirstByte;
333         bool m_isClientRedirect;
334         bool m_isLoadingMultipartContent;
335         bool m_loadingEmptyDocument;
336
337         // FIXME: Document::m_processingLoadEvent and DocumentLoader::m_wasOnloadHandled are roughly the same
338         // and should be merged.
339         bool m_wasOnloadHandled;
340
341         StringWithDirection m_pageTitle;
342
343         String m_overrideEncoding;
344
345         // The action that triggered loading - we keep this around for the
346         // benefit of the various policy handlers.
347         NavigationAction m_triggeringAction;
348
349         // The last request that we checked click policy for - kept around
350         // so we can avoid asking again needlessly.
351         ResourceRequest m_lastCheckedRequest;
352
353         // We retain all the received responses so we can play back the
354         // WebResourceLoadDelegate messages if the item is loaded from the
355         // page cache.
356         ResponseVector m_responses;
357         bool m_stopRecordingResponses;
358         
359         typedef HashMap<RefPtr<ResourceLoader>, RefPtr<SubstituteResource> > SubstituteResourceMap;
360         SubstituteResourceMap m_pendingSubstituteResources;
361         Timer<DocumentLoader> m_substituteResourceDeliveryTimer;
362
363         OwnPtr<ArchiveResourceCollection> m_archiveResourceCollection;
364 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
365         RefPtr<Archive> m_archive;
366         RefPtr<SharedBuffer> m_parsedArchiveData;
367 #endif
368
369         HashSet<String> m_resourcesClientKnowsAbout;
370         Vector<ResourceRequest> m_resourcesLoadedFromMemoryCacheForClientNotification;
371         
372         String m_clientRedirectSourceForHistory;
373         bool m_didCreateGlobalHistoryEntry;
374
375         DocumentLoadTiming m_documentLoadTiming;
376
377         double m_timeOfLastDataReceived;
378
379         bool m_waitingForContentPolicy;
380     
381         RefPtr<IconLoadDecisionCallback> m_iconLoadDecisionCallback;
382         RefPtr<IconDataCallback> m_iconDataCallback;
383
384         friend class ApplicationCacheHost;  // for substitute resource delivery
385         OwnPtr<ApplicationCacheHost> m_applicationCacheHost;
386
387 #if USE(CONTENT_FILTERING)
388         RefPtr<ContentFilter> m_contentFilter;
389 #endif
390     };
391
392     inline void DocumentLoader::recordMemoryCacheLoadForFutureClientNotification(const ResourceRequest& request)
393     {
394         m_resourcesLoadedFromMemoryCacheForClientNotification.append(request);
395     }
396
397     inline void DocumentLoader::takeMemoryCacheLoadsForClientNotification(Vector<ResourceRequest>& loadsSet)
398     {
399         loadsSet.swap(m_resourcesLoadedFromMemoryCacheForClientNotification);
400         m_resourcesLoadedFromMemoryCacheForClientNotification.clear();
401     }
402
403 }
404
405 #endif // DocumentLoader_h