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