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