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