Remove unnecessary parameter from DocumentLoader::scheduleArchiveLoad
[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 "DocumentLoadTiming.h"
34 #include "DocumentWriter.h"
35 #include "IconDatabaseBase.h"
36 #include "NavigationAction.h"
37 #include "ResourceError.h"
38 #include "ResourceRequest.h"
39 #include "ResourceResponse.h"
40 #include "StringWithDirection.h"
41 #include "SubstituteData.h"
42 #include "Timer.h"
43 #include <wtf/HashSet.h>
44 #include <wtf/RefPtr.h>
45 #include <wtf/Vector.h>
46
47 namespace WebCore {
48
49     class ApplicationCacheHost;
50 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
51     class Archive;
52 #endif
53     class ArchiveResource;
54     class ArchiveResourceCollection;
55     class CachedResourceLoader;
56     class Frame;
57     class FrameLoader;
58     class MainResourceLoader;
59     class Page;
60     class ResourceBuffer;
61     class ResourceLoader;
62     class SchedulePair;
63     class SharedBuffer;
64     class SubstituteResource;
65
66     typedef HashSet<RefPtr<ResourceLoader> > ResourceLoaderSet;
67     typedef Vector<ResourceResponse> ResponseVector;
68
69     class DocumentLoader : public RefCounted<DocumentLoader> {
70     public:
71         static PassRefPtr<DocumentLoader> create(const ResourceRequest& request, const SubstituteData& data)
72         {
73             return adoptRef(new DocumentLoader(request, data));
74         }
75         virtual ~DocumentLoader();
76
77         void setFrame(Frame*);
78         Frame* frame() const { return m_frame; }
79
80         virtual void attachToFrame();
81         virtual void detachFromFrame();
82
83         FrameLoader* frameLoader() const;
84         MainResourceLoader* mainResourceLoader() const { return m_mainResourceLoader.get(); }
85         PassRefPtr<ResourceBuffer> mainResourceData() const;
86         
87         DocumentWriter* writer() const { return &m_writer; }
88
89         const ResourceRequest& originalRequest() const;
90         const ResourceRequest& originalRequestCopy() const;
91
92         const ResourceRequest& request() const;
93         ResourceRequest& request();
94         void setRequest(const ResourceRequest&);
95
96         CachedResourceLoader* cachedResourceLoader() const { return m_cachedResourceLoader.get(); }
97
98         const SubstituteData& substituteData() const { return m_substituteData; }
99
100         // FIXME: This is the same as requestURL(). We should remove one of them.
101         const KURL& url() const;
102         const KURL& unreachableURL() const;
103
104         // The URL of the document resulting from this DocumentLoader.
105         KURL documentURL() const;
106
107         const KURL& originalURL() const;
108         const KURL& requestURL() const;
109         const KURL& responseURL() const;
110         const String& responseMIMEType() const;
111
112         void replaceRequestURLForSameDocumentNavigation(const KURL&);
113         bool isStopping() const { return m_isStopping; }
114         void stopLoading();
115         void setCommitted(bool committed) { m_committed = committed; }
116         bool isCommitted() const { return m_committed; }
117         bool isLoading() const { return isLoadingMainResource() || !m_subresourceLoaders.isEmpty() || !m_plugInStreamLoaders.isEmpty(); }
118         void receivedData(const char*, int);
119         void setupForReplace();
120         void finishedLoading();
121         const ResourceResponse& response() const { return m_response; }
122         const ResourceError& mainDocumentError() const { return m_mainDocumentError; }
123         void mainReceivedError(const ResourceError&);
124         void setResponse(const ResourceResponse& response) { m_response = response; }
125         bool isClientRedirect() const { return m_isClientRedirect; }
126         void setIsClientRedirect(bool isClientRedirect) { m_isClientRedirect = isClientRedirect; }
127         void handledOnloadEvents();
128         bool wasOnloadHandled() { return m_wasOnloadHandled; }
129         bool isLoadingInAPISense() const;
130         void setTitle(const StringWithDirection&);
131         const String& overrideEncoding() const { return m_overrideEncoding; }
132
133 #if PLATFORM(MAC)
134         void schedule(SchedulePair*);
135         void unschedule(SchedulePair*);
136 #endif
137
138 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
139         void setArchive(PassRefPtr<Archive>);
140         void addAllArchiveResources(Archive*);
141         void addArchiveResource(PassRefPtr<ArchiveResource>);
142         PassRefPtr<Archive> popArchiveForSubframe(const String& frameName, const KURL&);
143         SharedBuffer* parsedArchiveData() const;
144
145         bool scheduleArchiveLoad(ResourceLoader*, const ResourceRequest&);
146 #endif // ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
147
148         // Return the ArchiveResource for the URL only when loading an Archive
149         ArchiveResource* archiveResourceForURL(const KURL&) const;
150
151         PassRefPtr<ArchiveResource> mainResource() const;
152
153         // Return an ArchiveResource for the URL, either creating from live data or
154         // pulling from the ArchiveResourceCollection
155         PassRefPtr<ArchiveResource> subresource(const KURL&) const;
156         void getSubresources(Vector<PassRefPtr<ArchiveResource> >&) const;
157
158
159 #ifndef NDEBUG
160         bool isSubstituteLoadPending(ResourceLoader*) const;
161 #endif
162         void cancelPendingSubstituteLoad(ResourceLoader*);   
163         
164         void addResponse(const ResourceResponse&);
165         const ResponseVector& responses() const { return m_responses; }
166
167         const NavigationAction& triggeringAction() const { return m_triggeringAction; }
168         void setTriggeringAction(const NavigationAction& action) { m_triggeringAction = action; }
169         void setOverrideEncoding(const String& encoding) { m_overrideEncoding = encoding; }
170         void setLastCheckedRequest(const ResourceRequest& request) { m_lastCheckedRequest = request; }
171         const ResourceRequest& lastCheckedRequest()  { return m_lastCheckedRequest; }
172
173         void stopRecordingResponses();
174         const StringWithDirection& title() const { return m_pageTitle; }
175
176         KURL urlForHistory() const;
177         bool urlForHistoryReflectsFailure() const;
178
179         // These accessors accommodate WebCore's somewhat fickle custom of creating history
180         // items for redirects, but only sometimes. For "source" and "destination",
181         // these accessors return the URL that would have been used if a history
182         // item were created. This allows WebKit to link history items reflecting
183         // redirects into a chain from start to finish.
184         String clientRedirectSourceForHistory() const { return m_clientRedirectSourceForHistory; } // null if no client redirect occurred.
185         String clientRedirectDestinationForHistory() const { return urlForHistory(); }
186         void setClientRedirectSourceForHistory(const String& clientRedirectSourceForHistory) { m_clientRedirectSourceForHistory = clientRedirectSourceForHistory; }
187         
188         String serverRedirectSourceForHistory() const { return (urlForHistory() == url() || url() == blankURL()) ? String() : urlForHistory().string(); } // null if no server redirect occurred.
189         String serverRedirectDestinationForHistory() const { return url(); }
190
191         bool didCreateGlobalHistoryEntry() const { return m_didCreateGlobalHistoryEntry; }
192         void setDidCreateGlobalHistoryEntry(bool didCreateGlobalHistoryEntry) { m_didCreateGlobalHistoryEntry = didCreateGlobalHistoryEntry; }
193         
194         void setDefersLoading(bool);
195
196         void startLoadingMainResource();
197         void cancelMainResourceLoad(const ResourceError&);
198         
199         // Support iconDatabase in synchronous mode.
200         void iconLoadDecisionAvailable();
201         
202         // Support iconDatabase in asynchronous mode.
203         void continueIconLoadWithDecision(IconLoadDecision);
204         void getIconLoadDecisionForIconURL(const String&);
205         void getIconDataForIconURL(const String&);
206         
207         bool isLoadingMainResource() const;
208         bool isLoadingMultipartContent() const;
209
210         void stopLoadingPlugIns();
211         void stopLoadingSubresources();
212
213         void addSubresourceLoader(ResourceLoader*);
214         void removeSubresourceLoader(ResourceLoader*);
215         void addPlugInStreamLoader(ResourceLoader*);
216         void removePlugInStreamLoader(ResourceLoader*);
217
218         void subresourceLoaderFinishedLoadingOnePart(ResourceLoader*);
219
220         void maybeFinishLoadingMultipartContent();
221
222         void setDeferMainResourceDataLoad(bool defer) { m_deferMainResourceDataLoad = defer; }
223         bool deferMainResourceDataLoad() const { return m_deferMainResourceDataLoad; }
224         
225         void didTellClientAboutLoad(const String& url)
226         { 
227 #if !PLATFORM(MAC)
228             // Don't include data urls here, as if a lot of data is loaded
229             // that way, we hold on to the (large) url string for too long.
230             if (protocolIs(url, "data"))
231                 return;
232 #endif
233             if (!url.isEmpty())
234                 m_resourcesClientKnowsAbout.add(url);
235         }
236         bool haveToldClientAboutLoad(const String& url) { return m_resourcesClientKnowsAbout.contains(url); }
237         void recordMemoryCacheLoadForFutureClientNotification(const String& url);
238         void takeMemoryCacheLoadsForClientNotification(Vector<String>& loads);
239
240         DocumentLoadTiming* timing() { return &m_documentLoadTiming; }
241         void resetTiming() { m_documentLoadTiming = DocumentLoadTiming(); }
242
243         // The WebKit layer calls this function when it's ready for the data to
244         // actually be added to the document.
245         void commitData(const char* bytes, size_t length);
246
247         ApplicationCacheHost* applicationCacheHost() const { return m_applicationCacheHost.get(); }
248
249         virtual void reportMemoryUsage(MemoryObjectInfo*) const;
250
251     protected:
252         DocumentLoader(const ResourceRequest&, const SubstituteData&);
253
254         bool m_deferMainResourceDataLoad;
255
256     private:
257         void commitIfReady();
258         void setMainDocumentError(const ResourceError&);
259         void commitLoad(const char*, int);
260         void checkLoadComplete();
261         void clearMainResourceLoader();
262         
263         bool maybeCreateArchive();
264 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
265         void clearArchiveResources();
266 #endif
267
268         bool maybeLoadEmpty();
269
270         bool isMultipartReplacingLoad() const;
271
272         void deliverSubstituteResourcesAfterDelay();
273         void substituteResourceDeliveryTimerFired(Timer<DocumentLoader>*);
274                 
275         Frame* m_frame;
276         RefPtr<CachedResourceLoader> m_cachedResourceLoader;
277
278         RefPtr<MainResourceLoader> m_mainResourceLoader;
279         ResourceLoaderSet m_subresourceLoaders;
280         ResourceLoaderSet m_multipartSubresourceLoaders;
281         ResourceLoaderSet m_plugInStreamLoaders;
282
283         RefPtr<ResourceBuffer> m_mainResourceData;
284         
285         mutable DocumentWriter m_writer;
286
287         // A reference to actual request used to create the data source.
288         // This should only be used by the resourceLoadDelegate's
289         // identifierForInitialRequest:fromDatasource: method. It is
290         // not guaranteed to remain unchanged, as requests are mutable.
291         ResourceRequest m_originalRequest;   
292
293         SubstituteData m_substituteData;
294
295         // A copy of the original request used to create the data source.
296         // We have to copy the request because requests are mutable.
297         ResourceRequest m_originalRequestCopy;
298         
299         // The 'working' request. It may be mutated
300         // several times from the original request to include additional
301         // headers, cookie information, canonicalization and redirects.
302         ResourceRequest m_request;
303
304         ResourceResponse m_response;
305     
306         ResourceError m_mainDocumentError;    
307
308         bool m_committed;
309         bool m_isStopping;
310         bool m_gotFirstByte;
311         bool m_isClientRedirect;
312         bool m_loadingEmptyDocument;
313
314         // FIXME: Document::m_processingLoadEvent and DocumentLoader::m_wasOnloadHandled are roughly the same
315         // and should be merged.
316         bool m_wasOnloadHandled;
317
318         StringWithDirection m_pageTitle;
319
320         String m_overrideEncoding;
321
322         // The action that triggered loading - we keep this around for the
323         // benefit of the various policy handlers.
324         NavigationAction m_triggeringAction;
325
326         // The last request that we checked click policy for - kept around
327         // so we can avoid asking again needlessly.
328         ResourceRequest m_lastCheckedRequest;
329
330         // We retain all the received responses so we can play back the
331         // WebResourceLoadDelegate messages if the item is loaded from the
332         // page cache.
333         ResponseVector m_responses;
334         bool m_stopRecordingResponses;
335         
336         typedef HashMap<RefPtr<ResourceLoader>, RefPtr<SubstituteResource> > SubstituteResourceMap;
337         SubstituteResourceMap m_pendingSubstituteResources;
338         Timer<DocumentLoader> m_substituteResourceDeliveryTimer;
339
340         OwnPtr<ArchiveResourceCollection> m_archiveResourceCollection;
341 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
342         RefPtr<Archive> m_archive;
343         RefPtr<SharedBuffer> m_parsedArchiveData;
344 #endif
345
346         HashSet<String> m_resourcesClientKnowsAbout;
347         Vector<String> m_resourcesLoadedFromMemoryCacheForClientNotification;
348         
349         String m_clientRedirectSourceForHistory;
350         bool m_didCreateGlobalHistoryEntry;
351
352         DocumentLoadTiming m_documentLoadTiming;
353     
354         RefPtr<IconLoadDecisionCallback> m_iconLoadDecisionCallback;
355         RefPtr<IconDataCallback> m_iconDataCallback;
356
357         friend class ApplicationCacheHost;  // for substitute resource delivery
358         OwnPtr<ApplicationCacheHost> m_applicationCacheHost;
359     };
360
361     inline void DocumentLoader::recordMemoryCacheLoadForFutureClientNotification(const String& url)
362     {
363         m_resourcesLoadedFromMemoryCacheForClientNotification.append(url);
364     }
365
366     inline void DocumentLoader::takeMemoryCacheLoadsForClientNotification(Vector<String>& loadsSet)
367     {
368         loadsSet.swap(m_resourcesLoadedFromMemoryCacheForClientNotification);
369         m_resourcesLoadedFromMemoryCacheForClientNotification.clear();
370     }
371
372 }
373
374 #endif // DocumentLoader_h