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