Merge MainResourceLoader's SubstituteData loading + others into DocumentLoader
[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 #if HAVE(RUNLOOP_TIMER)
49 #include "RunLoopTimer.h"
50 #endif
51
52 namespace WTF {
53 class SchedulePair;
54 }
55
56 namespace WebCore {
57     class ApplicationCacheHost;
58 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
59     class Archive;
60 #endif
61     class ArchiveResource;
62     class ArchiveResourceCollection;
63     class CachedResourceLoader;
64     class ContentFilter;
65     class FormState;
66     class Frame;
67     class FrameLoader;
68     class MainResourceLoader;
69     class Page;
70     class ResourceBuffer;
71     class ResourceLoader;
72     class SharedBuffer;
73     class SubstituteResource;
74
75     typedef HashSet<RefPtr<ResourceLoader> > ResourceLoaderSet;
76     typedef Vector<ResourceResponse> ResponseVector;
77
78     class DocumentLoader : public RefCounted<DocumentLoader> {
79     public:
80         static PassRefPtr<DocumentLoader> create(const ResourceRequest& request, const SubstituteData& data)
81         {
82             return adoptRef(new DocumentLoader(request, data));
83         }
84         virtual ~DocumentLoader();
85
86         void setFrame(Frame*);
87         Frame* frame() const { return m_frame; }
88
89         virtual void attachToFrame();
90         virtual void detachFromFrame();
91
92         FrameLoader* frameLoader() const;
93         ResourceLoader* mainResourceLoader() const;
94         PassRefPtr<ResourceBuffer> mainResourceData() const;
95         
96         DocumentWriter* writer() const { return &m_writer; }
97         Document* document() const;
98
99         const ResourceRequest& originalRequest() const;
100         const ResourceRequest& originalRequestCopy() const;
101
102         const ResourceRequest& request() const;
103         ResourceRequest& request();
104         void setRequest(const ResourceRequest&);
105
106         CachedResourceLoader* cachedResourceLoader() const { return m_cachedResourceLoader.get(); }
107
108         const SubstituteData& substituteData() const { return m_substituteData; }
109
110         // FIXME: This is the same as requestURL(). We should remove one of them.
111         const KURL& url() const;
112         const KURL& unreachableURL() const;
113
114         // The URL of the document resulting from this DocumentLoader.
115         KURL documentURL() const;
116
117         const KURL& originalURL() const;
118         const KURL& requestURL() const;
119         const KURL& responseURL() const;
120         const String& responseMIMEType() const;
121
122         void replaceRequestURLForSameDocumentNavigation(const KURL&);
123         bool isStopping() const { return m_isStopping; }
124         void stopLoading();
125         void setCommitted(bool committed) { m_committed = committed; }
126         bool isCommitted() const { return m_committed; }
127         bool isLoading() const;
128         void receivedData(const char*, int);
129         void setupForReplace();
130         void finishedLoading(double finishTime);
131         const ResourceResponse& response() const { return m_response; }
132         const ResourceError& mainDocumentError() const { return m_mainDocumentError; }
133         void mainReceivedError(const ResourceError&);
134         void setResponse(const ResourceResponse& response) { m_response = response; }
135         bool isClientRedirect() const { return m_isClientRedirect; }
136         void setIsClientRedirect(bool isClientRedirect) { m_isClientRedirect = isClientRedirect; }
137         void handledOnloadEvents();
138         bool wasOnloadHandled() { return m_wasOnloadHandled; }
139         bool isLoadingInAPISense() const;
140         void setTitle(const StringWithDirection&);
141         const String& overrideEncoding() const { return m_overrideEncoding; }
142
143 #if PLATFORM(MAC)
144         void schedule(WTF::SchedulePair*);
145         void unschedule(WTF::SchedulePair*);
146 #endif
147
148 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
149         void setArchive(PassRefPtr<Archive>);
150         void addAllArchiveResources(Archive*);
151         void addArchiveResource(PassRefPtr<ArchiveResource>);
152         PassRefPtr<Archive> popArchiveForSubframe(const String& frameName, const KURL&);
153         SharedBuffer* parsedArchiveData() const;
154
155         bool scheduleArchiveLoad(ResourceLoader*, const ResourceRequest&);
156 #endif // ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
157
158         // Return the ArchiveResource for the URL only when loading an Archive
159         ArchiveResource* archiveResourceForURL(const KURL&) const;
160
161         PassRefPtr<ArchiveResource> mainResource() const;
162
163         // Return an ArchiveResource for the URL, either creating from live data or
164         // pulling from the ArchiveResourceCollection
165         PassRefPtr<ArchiveResource> subresource(const KURL&) const;
166         void getSubresources(Vector<PassRefPtr<ArchiveResource> >&) const;
167
168
169 #ifndef NDEBUG
170         bool isSubstituteLoadPending(ResourceLoader*) const;
171 #endif
172         void cancelPendingSubstituteLoad(ResourceLoader*);   
173         
174         void addResponse(const ResourceResponse&);
175         const ResponseVector& responses() const { return m_responses; }
176
177         const NavigationAction& triggeringAction() const { return m_triggeringAction; }
178         void setTriggeringAction(const NavigationAction& action) { m_triggeringAction = action; }
179         void setOverrideEncoding(const String& encoding) { m_overrideEncoding = encoding; }
180         void setLastCheckedRequest(const ResourceRequest& request) { m_lastCheckedRequest = request; }
181         const ResourceRequest& lastCheckedRequest()  { return m_lastCheckedRequest; }
182
183         void stopRecordingResponses();
184         const StringWithDirection& title() const { return m_pageTitle; }
185
186         KURL urlForHistory() const;
187         bool urlForHistoryReflectsFailure() const;
188
189         // These accessors accommodate WebCore's somewhat fickle custom of creating history
190         // items for redirects, but only sometimes. For "source" and "destination",
191         // these accessors return the URL that would have been used if a history
192         // item were created. This allows WebKit to link history items reflecting
193         // redirects into a chain from start to finish.
194         String clientRedirectSourceForHistory() const { return m_clientRedirectSourceForHistory; } // null if no client redirect occurred.
195         String clientRedirectDestinationForHistory() const { return urlForHistory(); }
196         void setClientRedirectSourceForHistory(const String& clientRedirectSourceForHistory) { m_clientRedirectSourceForHistory = clientRedirectSourceForHistory; }
197         
198         String serverRedirectSourceForHistory() const { return (urlForHistory() == url() || url() == blankURL()) ? String() : urlForHistory().string(); } // null if no server redirect occurred.
199         String serverRedirectDestinationForHistory() const { return url(); }
200
201         bool didCreateGlobalHistoryEntry() const { return m_didCreateGlobalHistoryEntry; }
202         void setDidCreateGlobalHistoryEntry(bool didCreateGlobalHistoryEntry) { m_didCreateGlobalHistoryEntry = didCreateGlobalHistoryEntry; }
203         
204         void setDefersLoading(bool);
205         void setMainResourceDataBufferingPolicy(DataBufferingPolicy);
206
207         void startLoadingMainResource();
208         void cancelMainResourceLoad(const ResourceError&);
209         
210         // Support iconDatabase in synchronous mode.
211         void iconLoadDecisionAvailable();
212         
213         // Support iconDatabase in asynchronous mode.
214         void continueIconLoadWithDecision(IconLoadDecision);
215         void getIconLoadDecisionForIconURL(const String&);
216         void getIconDataForIconURL(const String&);
217         
218         bool isLoadingMainResource() const;
219         bool isLoadingMultipartContent() const { return m_isLoadingMultipartContent; }
220
221         void stopLoadingPlugIns();
222         void stopLoadingSubresources();
223
224         void addSubresourceLoader(ResourceLoader*);
225         void removeSubresourceLoader(ResourceLoader*);
226         void addPlugInStreamLoader(ResourceLoader*);
227         void removePlugInStreamLoader(ResourceLoader*);
228
229         void subresourceLoaderFinishedLoadingOnePart(ResourceLoader*);
230
231         void maybeFinishLoadingMultipartContent();
232
233         void setDeferMainResourceDataLoad(bool defer) { m_deferMainResourceDataLoad = defer; }
234         bool deferMainResourceDataLoad() const { return m_deferMainResourceDataLoad; }
235         
236         void didTellClientAboutLoad(const String& url)
237         { 
238 #if !PLATFORM(MAC)
239             // Don't include data urls here, as if a lot of data is loaded
240             // that way, we hold on to the (large) url string for too long.
241             if (protocolIs(url, "data"))
242                 return;
243 #endif
244             if (!url.isEmpty())
245                 m_resourcesClientKnowsAbout.add(url);
246         }
247         bool haveToldClientAboutLoad(const String& url) { return m_resourcesClientKnowsAbout.contains(url); }
248         void recordMemoryCacheLoadForFutureClientNotification(const ResourceRequest&);
249         void takeMemoryCacheLoadsForClientNotification(Vector<ResourceRequest>& loads);
250
251         DocumentLoadTiming* timing() { return &m_documentLoadTiming; }
252         void resetTiming() { m_documentLoadTiming = DocumentLoadTiming(); }
253
254         void responseReceived(const ResourceResponse&);
255
256         // The WebKit layer calls this function when it's ready for the data to
257         // actually be added to the document.
258         void commitData(const char* bytes, size_t length);
259
260         ApplicationCacheHost* applicationCacheHost() const { return m_applicationCacheHost.get(); }
261
262         virtual void reportMemoryUsage(MemoryObjectInfo*) const;
263         void checkLoadComplete();
264
265         // FIXME: This should be private once DocumentLoader and MainResourceLoader are merged.
266         void willSendRequest(ResourceRequest&, const ResourceResponse&);
267
268     protected:
269         DocumentLoader(const ResourceRequest&, const SubstituteData&);
270
271         bool m_deferMainResourceDataLoad;
272
273     private:
274         void commitIfReady();
275         void setMainDocumentError(const ResourceError&);
276         void commitLoad(const char*, int);
277         void clearMainResourceLoader();
278         
279         bool maybeCreateArchive();
280 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
281         void clearArchiveResources();
282 #endif
283
284         bool maybeLoadEmpty();
285
286         bool isMultipartReplacingLoad() const;
287         bool isPostOrRedirectAfterPost(const ResourceRequest&, const ResourceResponse&);
288
289         static void callContinueAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
290         void continueAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
291
292         static void callContinueAfterContentPolicy(void*, PolicyAction);
293         void continueAfterContentPolicy(PolicyAction);
294
295         void stopLoadingForPolicyChange();
296         ResourceError interruptedForPolicyChangeError() const;
297
298 #if HAVE(RUNLOOP_TIMER)
299         typedef RunLoopTimer<DocumentLoader> DocumentLoaderTimer;
300 #else
301         typedef Timer<DocumentLoader> DocumentLoaderTimer;
302 #endif
303         void handleSubstituteDataLoadSoon();
304         void handleSubstituteDataLoadNow(DocumentLoaderTimer*);
305         void startDataLoadTimer();
306
307         void deliverSubstituteResourcesAfterDelay();
308         void substituteResourceDeliveryTimerFired(Timer<DocumentLoader>*);
309                 
310         Frame* m_frame;
311         RefPtr<CachedResourceLoader> m_cachedResourceLoader;
312
313         RefPtr<MainResourceLoader> m_mainResourceLoader;
314         ResourceLoaderSet m_subresourceLoaders;
315         ResourceLoaderSet m_multipartSubresourceLoaders;
316         ResourceLoaderSet m_plugInStreamLoaders;
317
318         RefPtr<ResourceBuffer> m_mainResourceData;
319         
320         mutable DocumentWriter m_writer;
321
322         // A reference to actual request used to create the data source.
323         // This should only be used by the resourceLoadDelegate's
324         // identifierForInitialRequest:fromDatasource: method. It is
325         // not guaranteed to remain unchanged, as requests are mutable.
326         ResourceRequest m_originalRequest;   
327
328         SubstituteData m_substituteData;
329
330         // A copy of the original request used to create the data source.
331         // We have to copy the request because requests are mutable.
332         ResourceRequest m_originalRequestCopy;
333         
334         // The 'working' request. It may be mutated
335         // several times from the original request to include additional
336         // headers, cookie information, canonicalization and redirects.
337         ResourceRequest m_request;
338
339         ResourceResponse m_response;
340     
341         ResourceError m_mainDocumentError;    
342
343         bool m_committed;
344         bool m_isStopping;
345         bool m_gotFirstByte;
346         bool m_isClientRedirect;
347         bool m_isLoadingMultipartContent;
348         bool m_loadingEmptyDocument;
349
350         // FIXME: Document::m_processingLoadEvent and DocumentLoader::m_wasOnloadHandled are roughly the same
351         // and should be merged.
352         bool m_wasOnloadHandled;
353
354         StringWithDirection m_pageTitle;
355
356         String m_overrideEncoding;
357
358         // The action that triggered loading - we keep this around for the
359         // benefit of the various policy handlers.
360         NavigationAction m_triggeringAction;
361
362         // The last request that we checked click policy for - kept around
363         // so we can avoid asking again needlessly.
364         ResourceRequest m_lastCheckedRequest;
365
366         // We retain all the received responses so we can play back the
367         // WebResourceLoadDelegate messages if the item is loaded from the
368         // page cache.
369         ResponseVector m_responses;
370         bool m_stopRecordingResponses;
371         
372         typedef HashMap<RefPtr<ResourceLoader>, RefPtr<SubstituteResource> > SubstituteResourceMap;
373         SubstituteResourceMap m_pendingSubstituteResources;
374         Timer<DocumentLoader> m_substituteResourceDeliveryTimer;
375
376         OwnPtr<ArchiveResourceCollection> m_archiveResourceCollection;
377 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
378         RefPtr<Archive> m_archive;
379         RefPtr<SharedBuffer> m_parsedArchiveData;
380 #endif
381
382         HashSet<String> m_resourcesClientKnowsAbout;
383         Vector<ResourceRequest> m_resourcesLoadedFromMemoryCacheForClientNotification;
384         
385         String m_clientRedirectSourceForHistory;
386         bool m_didCreateGlobalHistoryEntry;
387
388         DocumentLoadTiming m_documentLoadTiming;
389
390         double m_timeOfLastDataReceived;
391         unsigned long m_identifierForLoadWithoutResourceLoader;
392
393         DocumentLoaderTimer m_dataLoadTimer;
394         bool m_waitingForContentPolicy;
395
396         RefPtr<IconLoadDecisionCallback> m_iconLoadDecisionCallback;
397         RefPtr<IconDataCallback> m_iconDataCallback;
398
399         friend class ApplicationCacheHost;  // for substitute resource delivery
400         OwnPtr<ApplicationCacheHost> m_applicationCacheHost;
401
402 #if USE(CONTENT_FILTERING)
403         RefPtr<ContentFilter> m_contentFilter;
404 #endif
405     };
406
407     inline void DocumentLoader::recordMemoryCacheLoadForFutureClientNotification(const ResourceRequest& request)
408     {
409         m_resourcesLoadedFromMemoryCacheForClientNotification.append(request);
410     }
411
412     inline void DocumentLoader::takeMemoryCacheLoadsForClientNotification(Vector<ResourceRequest>& loadsSet)
413     {
414         loadsSet.swap(m_resourcesLoadedFromMemoryCacheForClientNotification);
415         m_resourcesLoadedFromMemoryCacheForClientNotification.clear();
416     }
417
418 }
419
420 #endif // DocumentLoader_h