Reviewed by Steve.
[WebKit-https.git] / WebCore / loader / FrameLoader.h
1 /*
2  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer. 
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution. 
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission. 
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "FrameLoaderTypes.h"
30 #include "PlatformString.h"
31 #include <wtf/Forward.h>
32 #include <wtf/HashSet.h>
33 #include <wtf/HashMap.h>
34 #include <wtf/Noncopyable.h>
35 #include <wtf/RefPtr.h>
36
37 #if PLATFORM(MAC)
38
39 #import "RetainPtr.h"
40 #import <objc/objc.h>
41
42 #ifdef __OBJC__
43
44 @class NSData;
45 @class NSDictionary;
46 @class NSError;
47 @class NSEvent;
48 @class NSMutableURLRequest;
49 @class NSURL;
50 @class NSURLAuthenticationChallenge;
51 @class NSURLConnection;
52 @class NSURLRequest;
53 @class NSURLResponse;
54
55 #else
56
57 class NSData;
58 class NSDictionary;
59 class NSError;
60 class NSEvent;
61 class NSMutableURLRequest;
62 class NSURL;
63 class NSURLAuthenticationChallenge;
64 class NSURLConnection;
65 class NSURLRequest;
66 class NSURLResponse;
67
68 #endif // __OBJC__
69
70 #endif // PLATFORM(MAC)
71
72 namespace WebCore {
73
74     class DocumentLoader;
75     class Element;
76     class FormData;
77     class FormState;
78     class Frame;
79     struct FrameLoadRequest;
80     class FrameLoaderClient;
81     class KURL;
82     class MainResourceLoader;
83     class PageState;
84     class ResourceLoader;
85     class ResourceRequest;
86     class ResourceResponse;
87     class String;
88     class SubresourceLoader;
89     struct WindowFeatures;
90
91     typedef HashSet<RefPtr<ResourceLoader> > ResourceLoaderSet;
92
93     bool isBackForwardLoadType(FrameLoadType);
94
95 #if PLATFORM(MAC)
96     typedef void (*NavigationPolicyDecisionFunction)(void* argument,
97         NSURLRequest *, PassRefPtr<FormState>);
98     typedef void (*NewWindowPolicyDecisionFunction)(void* argument,
99         NSURLRequest *, PassRefPtr<FormState>, const String& frameName);
100     typedef void (*ContentPolicyDecisionFunction)(void* argument, PolicyAction);
101
102     class PolicyCheck {
103     public:
104         PolicyCheck();
105
106         void clear();
107         void set(NSURLRequest *, PassRefPtr<FormState>,
108             NavigationPolicyDecisionFunction, void* argument);
109         void set(NSURLRequest *, PassRefPtr<FormState>, const String& frameName,
110             NewWindowPolicyDecisionFunction, void* argument);
111         void set(ContentPolicyDecisionFunction, void* argument);
112
113         NSURLRequest *request() const { return m_request.get(); }
114         void clearRequest();
115
116         void call();
117         void call(PolicyAction);
118
119     private:
120         RetainPtr<NSURLRequest> m_request;
121         RefPtr<FormState> m_formState;
122         String m_frameName;
123
124         NavigationPolicyDecisionFunction m_navigationFunction;
125         NewWindowPolicyDecisionFunction m_newWindowFunction;
126         ContentPolicyDecisionFunction m_contentFunction;
127         void* m_argument;
128     };
129 #endif
130
131     class FrameLoader : Noncopyable {
132     public:
133         FrameLoader(Frame*);
134         ~FrameLoader();
135
136         Frame* frame() const { return m_frame; }
137
138         // FIXME: This is not cool, people.
139         void prepareForLoadStart();
140         void setupForReplace();
141         void setupForReplaceByMIMEType(const String& newMIMEType);
142         void finalSetupForReplace(DocumentLoader*);
143 #if PLATFORM(MAC)
144         void safeLoad(NSURL *);
145         void load(const FrameLoadRequest&, bool userGesture, NSEvent* triggeringEvent,
146             Element* form, const HashMap<String, String>& formValues);
147         void load(NSURL *, const String& referrer, FrameLoadType, const String& target,
148             NSEvent *event, Element* form, const HashMap<String, String>& formValues);
149         void post(NSURL *, const String& referrer, const String& target,
150             const FormData&, const String& contentType,
151             NSEvent *, Element* form, const HashMap<String, String>&);
152         void load(NSURLRequest *);
153         void load(NSURLRequest *, const String& frameName);
154         void load(NSURLRequest *, NSDictionary *triggeringAaction, FrameLoadType, PassRefPtr<FormState>);
155 #endif
156         void load(DocumentLoader*);
157         void load(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>);
158
159 #if PLATFORM(MAC)
160         bool canLoad(NSURL *, const String& referrer, bool& hideReferrer);
161 #endif
162
163         Frame* createWindow(const FrameLoadRequest&, const WindowFeatures&);
164
165         void loadResourceSynchronously(const ResourceRequest& request, Vector<char>& data, ResourceResponse& r);
166
167         // Also not cool.
168         void stopLoadingPlugIns();
169         void stopLoadingSubresources();
170 #if PLATFORM(MAC)
171         void stopLoading(NSError *);
172 #endif
173         void stopLoading();
174         void cancelMainResourceLoad();
175         void cancelPendingArchiveLoad(ResourceLoader*);
176
177         void addPlugInStreamLoader(ResourceLoader*);
178         void removePlugInStreamLoader(ResourceLoader*);
179         bool isLoadingMainResource() const;
180         bool isLoadingSubresources() const;
181         bool isLoading() const;
182         void addSubresourceLoader(ResourceLoader*);
183         void removeSubresourceLoader(ResourceLoader*);
184 #if PLATFORM(MAC)
185         NSData *mainResourceData() const;
186 #endif
187         void releaseMainResourceLoader();
188
189         int numPendingOrLoadingRequests(bool recurse) const;
190         bool isReloading() const;
191         String referrer() const;
192         void loadEmptyDocumentSynchronously();
193
194         DocumentLoader* activeDocumentLoader() const;
195         DocumentLoader* documentLoader() const;
196         DocumentLoader* provisionalDocumentLoader();
197         FrameState state() const;
198         static double timeOfLastCompletedLoad();
199
200 #if PLATFORM(MAC)
201         id identifierForInitialRequest(NSURLRequest *);
202         NSURLRequest *willSendRequest(ResourceLoader*, NSMutableURLRequest *, NSURLResponse *redirectResponse);
203         void didReceiveAuthenticationChallenge(ResourceLoader*, NSURLAuthenticationChallenge *);
204         void didCancelAuthenticationChallenge(ResourceLoader*, NSURLAuthenticationChallenge *);
205         void didReceiveResponse(ResourceLoader*, NSURLResponse *);
206         void didReceiveData(ResourceLoader*, NSData *, int lengthReceived);
207         void didFinishLoad(ResourceLoader*);
208         void didFailToLoad(ResourceLoader*, NSError *);
209 #endif
210         bool privateBrowsingEnabled() const;
211 #if PLATFORM(MAC)
212         NSURLRequest *originalRequest() const;
213         void receivedMainResourceError(NSError *, bool isComplete);
214         NSURLRequest *initialRequest() const;
215         void receivedData(NSData *);
216         void setRequest(NSURLRequest *);
217         void download(NSURLConnection *, NSURLRequest *request, NSURLResponse *, id proxy);
218 #endif
219         void handleFallbackContent();
220         bool isStopping() const;
221 #if PLATFORM(MAC)
222         void setResponse(NSURLResponse *);
223 #endif
224
225         void finishedLoading();
226 #if PLATFORM(MAC)
227         NSURL *URL() const;
228 #endif
229
230 #if PLATFORM(MAC)
231         NSError *cancelledError(NSURLRequest *) const;
232         NSError *fileDoesNotExistError(NSURLResponse *) const;
233         bool willUseArchive(ResourceLoader*, NSURLRequest *, NSURL *) const;
234         bool isArchiveLoadPending(ResourceLoader*) const;
235         void cannotShowMIMEType(NSURLResponse *);
236         NSError *interruptionForPolicyChangeError(NSURLRequest *);
237 #endif
238
239         bool isHostedByObjectElement() const;
240         bool isLoadingMainFrame() const;
241         bool canShowMIMEType(const String& MIMEType) const;
242         bool representationExistsForURLScheme(const String& URLScheme);
243         String generatedMIMETypeForURLScheme(const String& URLScheme);
244
245 #if PLATFORM(MAC)
246         void notifyIconChanged(NSURL *iconURL);
247
248         void checkNavigationPolicy(NSURLRequest *, NavigationPolicyDecisionFunction, void* argument);
249         void checkContentPolicy(const String& MIMEType, ContentPolicyDecisionFunction, void* argument);
250 #endif
251         void cancelContentPolicyCheck();
252
253         void reload();
254         void reloadAllowingStaleData(const String& overrideEncoding);
255
256         void didReceiveServerRedirectForProvisionalLoadForFrame();
257         void finishedLoadingDocument(DocumentLoader*);
258 #if PLATFORM(MAC)
259         void committedLoad(DocumentLoader*, NSData *);
260 #endif
261         bool isReplacing() const;
262         void setReplacing();
263         void revertToProvisional(DocumentLoader*);
264 #if PLATFORM(MAC)
265         void setMainDocumentError(DocumentLoader*, NSError *);
266         void mainReceivedCompleteError(DocumentLoader*, NSError *);
267 #endif
268         bool subframeIsLoading() const;
269         void willChangeTitle(DocumentLoader*);
270         void didChangeTitle(DocumentLoader*);
271
272         FrameLoadType loadType() const;
273
274         void didFirstLayout();
275         bool firstLayoutDone() const;
276
277         void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
278 #if PLATFORM(MAC)
279         void clientRedirected(NSURL *, double delay, double fireDate, bool lockHistory, bool isJavaScriptFormAction);
280         void commitProvisionalLoad(NSDictionary *pageCache);
281         bool shouldReload(NSURL *currentURL, NSURL *destinationURL);
282 #endif
283
284         bool isQuickRedirectComing() const;
285
286 #if PLATFORM(MAC)
287         void sendRemainingDelegateMessages(id identifier, NSURLResponse *, unsigned length, NSError *);
288         NSURLRequest *requestFromDelegate(NSURLRequest *, id& identifier, NSError *& error);
289         void loadedResourceFromMemoryCache(NSURLRequest *request, NSURLResponse *response, int length);
290 #endif
291
292         void checkLoadComplete();
293         void detachFromParent();
294         void detachChildren();
295
296 #if PLATFORM(MAC)
297         void addExtraFieldsToRequest(NSMutableURLRequest *, bool isMainResource, bool alwaysFromRequest);
298         NSDictionary *actionInformation(NavigationType, NSEvent *, NSURL *);
299         NSDictionary *actionInformation(FrameLoadType loadType, bool isFormSubmission, NSEvent *, NSURL *);
300 #endif
301
302         void setClient(FrameLoaderClient*);
303         FrameLoaderClient* client() const;
304
305         void setDefersLoading(bool);
306
307     private:
308         // Also not cool.
309         void startLoading();
310 #if PLATFORM(MAC)
311         bool startLoadingMainResource(NSMutableURLRequest *, id identifier);
312 #endif
313         void stopLoadingSubframes();
314
315         void clearProvisionalLoad();
316         void markLoadComplete();
317         void commitProvisionalLoad();
318         void provisionalLoadStarted();
319         void frameLoadCompleted();
320
321 #if PLATFORM(MAC)
322         void mainReceivedError(NSError *, bool isComplete);
323 #endif
324
325         void setLoadType(FrameLoadType);
326
327 #if PLATFORM(MAC)
328         void checkNavigationPolicy(NSURLRequest *, DocumentLoader*, PassRefPtr<FormState>,
329             NavigationPolicyDecisionFunction, void* argument);
330         void checkNewWindowPolicy(NSDictionary *, NSURLRequest *, PassRefPtr<FormState>, const String& frameName);
331 #endif
332
333         void continueAfterNavigationPolicy(PolicyAction);
334         void continueAfterNewWindowPolicy(PolicyAction);
335         void continueAfterContentPolicy(PolicyAction);
336         void continueAfterWillSubmitForm(PolicyAction = PolicyUse);
337
338 #if PLATFORM(MAC)
339         static void callContinueLoadAfterNavigationPolicy(void*, NSURLRequest *, PassRefPtr<FormState>);
340         void continueLoadAfterNavigationPolicy(NSURLRequest *, PassRefPtr<FormState>);
341         static void callContinueLoadAfterNewWindowPolicy(void*, NSURLRequest *, PassRefPtr<FormState>, const String& frameName);
342         void continueLoadAfterNewWindowPolicy(NSURLRequest *, PassRefPtr<FormState>, const String& frameName);
343         static void callContinueFragmentScrollAfterNavigationPolicy(void*, NSURLRequest *, PassRefPtr<FormState>);
344         void continueFragmentScrollAfterNavigationPolicy(NSURLRequest *);
345 #endif
346
347         void stopPolicyCheck();
348
349         void closeDocument();
350
351 #if PLATFORM(MAC)
352         void transitionToCommitted(NSDictionary *pageCache);
353 #endif
354         void checkLoadCompleteForThisFrame();
355
356         void setDocumentLoader(DocumentLoader*);
357         void setPolicyDocumentLoader(DocumentLoader*);
358         void setProvisionalDocumentLoader(DocumentLoader*);
359
360         bool isLoadingPlugIns() const;
361
362         void setState(FrameState);
363
364         void closeOldDataSources();
365         void open(PageState&);
366         void opened();
367
368 #if PLATFORM(MAC)
369         void handleUnimplementablePolicy(NSError *);
370         bool shouldReloadToHandleUnreachableURL(NSURLRequest *);
371 #endif
372
373         bool canTarget(Frame*) const;
374
375         Frame* m_frame;
376         FrameLoaderClient* m_client;
377
378         FrameState m_state;
379         FrameLoadType m_loadType;
380
381         RefPtr<MainResourceLoader> m_mainResourceLoader;
382         ResourceLoaderSet m_subresourceLoaders;
383         ResourceLoaderSet m_plugInStreamLoaders;
384
385 #if PLATFORM(MAC)
386         RefPtr<DocumentLoader> m_documentLoader;
387         RefPtr<DocumentLoader> m_provisionalDocumentLoader;
388         RefPtr<DocumentLoader> m_policyDocumentLoader;
389 #endif
390
391         FrameLoadType m_policyLoadType;
392 #if PLATFORM(MAC)
393         PolicyCheck m_policyCheck;
394 #endif
395
396         bool m_delegateIsHandlingProvisionalLoadError;
397         bool m_delegateIsDecidingNavigationPolicy;
398         bool m_delegateIsHandlingUnimplementablePolicy;
399
400         bool m_firstLayoutDone;
401         bool m_quickRedirectComing;
402         bool m_sentRedirectNotification;
403         bool m_isStoppingLoad;
404     };
405
406 }