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