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