1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
|
/*
* Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef DocumentLoader_h
#define DocumentLoader_h
#include "NavigationAction.h"
#include "ResourceError.h"
#include "ResourceRequest.h"
#include "ResourceResponse.h"
#include "SubstituteData.h"
#include "Timer.h"
namespace WebCore {
class ApplicationCache;
class ApplicationCacheGroup;
class ApplicationCacheResource;
#if ENABLE(ARCHIVE) // ANDROID extension: disabled to reduce code size
class Archive;
class ArchiveResource;
class ArchiveResourceCollection;
#endif
class CachedPage;
class Frame;
class FrameLoader;
class MainResourceLoader;
class ResourceLoader;
class SchedulePair;
class SharedBuffer;
class SubstituteResource;
typedef HashSet<RefPtr<ResourceLoader> > ResourceLoaderSet;
typedef Vector<ResourceResponse> ResponseVector;
class DocumentLoader : public RefCounted<DocumentLoader> {
public:
static PassRefPtr<DocumentLoader> create(const ResourceRequest& request, const SubstituteData& data)
{
return adoptRef(new DocumentLoader(request, data));
}
virtual ~DocumentLoader();
void setFrame(Frame*);
Frame* frame() const { return m_frame; }
virtual void attachToFrame();
virtual void detachFromFrame();
FrameLoader* frameLoader() const;
MainResourceLoader* mainResourceLoader() const { return m_mainResourceLoader.get(); }
PassRefPtr<SharedBuffer> mainResourceData() const;
const ResourceRequest& originalRequest() const;
const ResourceRequest& originalRequestCopy() const;
const ResourceRequest& request() const;
ResourceRequest& request();
void setRequest(const ResourceRequest&);
const SubstituteData& substituteData() const { return m_substituteData; }
const KURL& url() const;
const KURL& unreachableURL() const;
const KURL& originalURL() const;
const KURL& requestURL() const;
const KURL& responseURL() const;
const String& responseMIMEType() const;
void replaceRequestURLForAnchorScroll(const KURL&);
bool isStopping() const { return m_isStopping; }
void stopLoading(DatabasePolicy = DatabasePolicyStop);
void setCommitted(bool committed) { m_committed = committed; }
bool isCommitted() const { return m_committed; }
bool isLoading() const { return m_loading; }
void setLoading(bool loading) { m_loading = loading; }
void updateLoading();
void receivedData(const char*, int);
void setupForReplaceByMIMEType(const String& newMIMEType);
void finishedLoading();
const ResourceResponse& response() const { return m_response; }
const ResourceError& mainDocumentError() const { return m_mainDocumentError; }
void mainReceivedError(const ResourceError&, bool isComplete);
void setResponse(const ResourceResponse& response) { m_response = response; }
void prepareForLoadStart();
bool isClientRedirect() const { return m_isClientRedirect; }
void setIsClientRedirect(bool isClientRedirect) { m_isClientRedirect = isClientRedirect; }
bool isLoadingInAPISense() const;
void setPrimaryLoadComplete(bool);
void setTitle(const String&);
const String& overrideEncoding() const { return m_overrideEncoding; }
#if PLATFORM(MAC)
void schedule(SchedulePair*);
void unschedule(SchedulePair*);
#endif
#if ENABLE(ARCHIVE) // ANDROID extension: disabled to reduce code size
void addAllArchiveResources(Archive*);
void addArchiveResource(PassRefPtr<ArchiveResource>);
// Return an ArchiveResource for the URL, either creating from live data or
// pulling from the ArchiveResourceCollection
PassRefPtr<ArchiveResource> subresource(const KURL&) const;
// Return the ArchiveResource for the URL only when loading an Archive
ArchiveResource* archiveResourceForURL(const KURL&) const;
PassRefPtr<Archive> popArchiveForSubframe(const String& frameName);
void clearArchiveResources();
void setParsedArchiveData(PassRefPtr<SharedBuffer>);
SharedBuffer* parsedArchiveData() const;
PassRefPtr<ArchiveResource> mainResource() const;
void getSubresources(Vector<PassRefPtr<ArchiveResource> >&) const;
bool scheduleArchiveLoad(ResourceLoader*, const ResourceRequest&, const KURL&);
#endif
#ifndef NDEBUG
bool isSubstituteLoadPending(ResourceLoader*) const;
#endif
void cancelPendingSubstituteLoad(ResourceLoader*);
void addResponse(const ResourceResponse&);
const ResponseVector& responses() const { return m_responses; }
const NavigationAction& triggeringAction() const { return m_triggeringAction; }
void setTriggeringAction(const NavigationAction& action) { m_triggeringAction = action; }
void setOverrideEncoding(const String& encoding) { m_overrideEncoding = encoding; }
void setLastCheckedRequest(const ResourceRequest& request) { m_lastCheckedRequest = request; }
const ResourceRequest& lastCheckedRequest() { return m_lastCheckedRequest; }
void stopRecordingResponses();
const String& title() const { return m_pageTitle; }
KURL urlForHistory() const;
bool urlForHistoryReflectsFailure() const;
// These accessors accomodate WebCore's somewhat fickle custom of creating history
// items for redirects, but only sometimes. For "source" and "destination",
// these accessors return the URL that would have been used if a history
// item were created. This allows WebKit to link history items reflecting
// redirects into a chain from start to finish.
String clientRedirectSourceForHistory() const { return m_clientRedirectSourceForHistory; } // null if no client redirect occurred.
String clientRedirectDestinationForHistory() const { return urlForHistory(); }
void setClientRedirectSourceForHistory(const String& clientedirectSourceForHistory) { m_clientRedirectSourceForHistory = clientedirectSourceForHistory; }
String serverRedirectSourceForHistory() const { return urlForHistory() == url() ? String() : urlForHistory(); } // null if no server redirect occurred.
String serverRedirectDestinationForHistory() const { return url(); }
bool didCreateGlobalHistoryEntry() const { return m_didCreateGlobalHistoryEntry; }
void setDidCreateGlobalHistoryEntry(bool didCreateGlobalHistoryEntry) { m_didCreateGlobalHistoryEntry = didCreateGlobalHistoryEntry; }
void loadFromCachedPage(PassRefPtr<CachedPage>);
void setLoadingFromCachedPage(bool loading) { m_loadingFromCachedPage = loading; }
bool isLoadingFromCachedPage() const { return m_loadingFromCachedPage; }
void setDefersLoading(bool);
bool startLoadingMainResource(unsigned long identifier);
void cancelMainResourceLoad(const ResourceError&);
void iconLoadDecisionAvailable();
bool isLoadingMainResource() const;
bool isLoadingSubresources() const;
bool isLoadingPlugIns() const;
bool isLoadingMultipartContent() const;
void stopLoadingPlugIns();
void stopLoadingSubresources();
void addSubresourceLoader(ResourceLoader*);
void removeSubresourceLoader(ResourceLoader*);
void addPlugInStreamLoader(ResourceLoader*);
void removePlugInStreamLoader(ResourceLoader*);
void subresourceLoaderFinishedLoadingOnePart(ResourceLoader*);
void setDeferMainResourceDataLoad(bool defer) { m_deferMainResourceDataLoad = defer; }
bool deferMainResourceDataLoad() const { return m_deferMainResourceDataLoad; }
void didTellClientAboutLoad(const String& url) { m_resourcesClientKnowsAbout.add(url); }
bool haveToldClientAboutLoad(const String& url) { return m_resourcesClientKnowsAbout.contains(url); }
void recordMemoryCacheLoadForFutureClientNotification(const String& url);
void takeMemoryCacheLoadsForClientNotification(Vector<String>& loads);
#if ENABLE(OFFLINE_WEB_APPLICATIONS)
bool scheduleApplicationCacheLoad(ResourceLoader*, const ResourceRequest&, const KURL& originalURL);
bool scheduleLoadFallbackResourceFromApplicationCache(ResourceLoader*, const ResourceRequest&, ApplicationCache* = 0);
bool shouldLoadResourceFromApplicationCache(const ResourceRequest&, ApplicationCacheResource*&);
bool getApplicationCacheFallbackResource(const ResourceRequest&, ApplicationCacheResource*&, ApplicationCache* = 0);
void setCandidateApplicationCacheGroup(ApplicationCacheGroup* group);
ApplicationCacheGroup* candidateApplicationCacheGroup() const { return m_candidateApplicationCacheGroup; }
void setApplicationCache(PassRefPtr<ApplicationCache> applicationCache);
ApplicationCache* applicationCache() const { return m_applicationCache.get(); }
ApplicationCache* mainResourceApplicationCache() const;
#endif
protected:
DocumentLoader(const ResourceRequest&, const SubstituteData&);
bool m_deferMainResourceDataLoad;
private:
void setupForReplace();
void commitIfReady();
void clearErrors();
void setMainDocumentError(const ResourceError&);
void commitLoad(const char*, int);
bool doesProgressiveLoad(const String& MIMEType) const;
void deliverSubstituteResourcesAfterDelay();
void substituteResourceDeliveryTimerFired(Timer<DocumentLoader>*);
Frame* m_frame;
RefPtr<MainResourceLoader> m_mainResourceLoader;
ResourceLoaderSet m_subresourceLoaders;
ResourceLoaderSet m_multipartSubresourceLoaders;
ResourceLoaderSet m_plugInStreamLoaders;
RefPtr<SharedBuffer> m_mainResourceData;
// A reference to actual request used to create the data source.
// This should only be used by the resourceLoadDelegate's
// identifierForInitialRequest:fromDatasource: method. It is
// not guaranteed to remain unchanged, as requests are mutable.
ResourceRequest m_originalRequest;
SubstituteData m_substituteData;
// A copy of the original request used to create the data source.
// We have to copy the request because requests are mutable.
ResourceRequest m_originalRequestCopy;
// The 'working' request. It may be mutated
// several times from the original request to include additional
// headers, cookie information, canonicalization and redirects.
ResourceRequest m_request;
ResourceResponse m_response;
ResourceError m_mainDocumentError;
bool m_committed;
bool m_isStopping;
bool m_loading;
bool m_gotFirstByte;
bool m_primaryLoadComplete;
bool m_isClientRedirect;
bool m_loadingFromCachedPage;
String m_pageTitle;
String m_overrideEncoding;
// The action that triggered loading - we keep this around for the
// benefit of the various policy handlers.
NavigationAction m_triggeringAction;
// The last request that we checked click policy for - kept around
// so we can avoid asking again needlessly.
ResourceRequest m_lastCheckedRequest;
// We retain all the received responses so we can play back the
// WebResourceLoadDelegate messages if the item is loaded from the
// page cache.
ResponseVector m_responses;
bool m_stopRecordingResponses;
typedef HashMap<RefPtr<ResourceLoader>, RefPtr<SubstituteResource> > SubstituteResourceMap;
SubstituteResourceMap m_pendingSubstituteResources;
Timer<DocumentLoader> m_substituteResourceDeliveryTimer;
#if ENABLE(ARCHIVE) // ANDROID extension: disabled to reduce code size
OwnPtr<ArchiveResourceCollection> m_archiveResourceCollection;
RefPtr<SharedBuffer> m_parsedArchiveData;
#endif
HashSet<String> m_resourcesClientKnowsAbout;
Vector<String> m_resourcesLoadedFromMemoryCacheForClientNotification;
String m_clientRedirectSourceForHistory;
bool m_didCreateGlobalHistoryEntry;
#if ENABLE(OFFLINE_WEB_APPLICATIONS)
// The application cache that the document loader is associated with (if any).
RefPtr<ApplicationCache> m_applicationCache;
// Before an application cache has finished loading, this will be the candidate application
// group that the document loader is associated with.
ApplicationCacheGroup* m_candidateApplicationCacheGroup;
// Once the main resource has finished loading, this is the application cache it was loaded from (if any).
RefPtr<ApplicationCache> m_mainResourceApplicationCache;
#endif
};
inline void DocumentLoader::recordMemoryCacheLoadForFutureClientNotification(const String& url)
{
m_resourcesLoadedFromMemoryCacheForClientNotification.append(url);
}
inline void DocumentLoader::takeMemoryCacheLoadsForClientNotification(Vector<String>& loadsSet)
{
loadsSet.swap(m_resourcesLoadedFromMemoryCacheForClientNotification);
m_resourcesLoadedFromMemoryCacheForClientNotification.clear();
}
}
#endif // DocumentLoader_h
|