2009-03-27 Darin Adler <darin@apple.com>
[WebKit-https.git] / WebCore / loader / FrameLoader.h
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
3  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
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 FrameLoader_h
31 #define FrameLoader_h
32
33 #include "CachePolicy.h"
34 #include "FrameLoaderTypes.h"
35 #include "ResourceRequest.h"
36 #include "Timer.h"
37
38 namespace WebCore {
39
40     class Archive;
41     class AuthenticationChallenge;
42     class CachedFrame;
43     class CachedPage;
44     class CachedResource;
45     class Document;
46     class DocumentLoader;
47     class Event;
48     class FormData;
49     class FormState;
50     class Frame;
51     class FrameLoaderClient;
52     class HistoryItem;
53     class HTMLAppletElement;
54     class HTMLFormElement;
55     class HTMLFrameOwnerElement;
56     class IconLoader;
57     class IntSize;
58     class NavigationAction;
59     class RenderPart;
60     class ResourceError;
61     class ResourceLoader;
62     class ResourceResponse;
63     class ScriptSourceCode;
64     class ScriptValue;
65     class SecurityOrigin;
66     class SharedBuffer;
67     class SubstituteData;
68     class TextResourceDecoder;
69     class Widget;
70
71     struct FormSubmission;
72     struct FrameLoadRequest;
73     struct ScheduledRedirection;
74     struct WindowFeatures;
75
76     bool isBackForwardLoadType(FrameLoadType);
77
78     typedef void (*NavigationPolicyDecisionFunction)(void* argument,
79         const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
80     typedef void (*NewWindowPolicyDecisionFunction)(void* argument,
81         const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
82     typedef void (*ContentPolicyDecisionFunction)(void* argument, PolicyAction);
83
84     class PolicyCheck {
85     public:
86         PolicyCheck();
87
88         void clear();
89         void set(const ResourceRequest&, PassRefPtr<FormState>,
90             NavigationPolicyDecisionFunction, void* argument);
91         void set(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName,
92             NewWindowPolicyDecisionFunction, void* argument);
93         void set(ContentPolicyDecisionFunction, void* argument);
94
95         const ResourceRequest& request() const { return m_request; }
96         void clearRequest();
97
98         void call(bool shouldContinue);
99         void call(PolicyAction);
100         void cancel();
101
102     private:
103         ResourceRequest m_request;
104         RefPtr<FormState> m_formState;
105         String m_frameName;
106
107         NavigationPolicyDecisionFunction m_navigationFunction;
108         NewWindowPolicyDecisionFunction m_newWindowFunction;
109         ContentPolicyDecisionFunction m_contentFunction;
110         void* m_argument;
111     };
112
113     class FrameLoader : Noncopyable {
114     public:
115         FrameLoader(Frame*, FrameLoaderClient*);
116         ~FrameLoader();
117
118         void init();
119
120         Frame* frame() const { return m_frame; }
121
122         // FIXME: This is not cool, people. We should aim to consolidate these variety of loading related methods into a smaller set,
123         // and try to reuse more of the same logic by extracting common code paths.
124         void prepareForLoadStart();
125         void setupForReplace();
126         void setupForReplaceByMIMEType(const String& newMIMEType);
127
128         void loadURLIntoChildFrame(const KURL&, const String& referer, Frame*);
129
130         void loadFrameRequestWithFormAndValues(const FrameLoadRequest&, bool lockHistory, bool lockBackForwardList,           // Called by submitForm, calls loadPostRequest()
131             PassRefPtr<Event>, HTMLFormElement*, const HashMap<String, String>& formValues);
132
133         void load(const ResourceRequest&, bool lockHistory);                                                          // Called by WebFrame, calls (ResourceRequest, SubstituteData)
134         void load(const ResourceRequest&, const SubstituteData&, bool lockHistory);                                   // Called both by WebFrame and internally, calls (DocumentLoader*)
135         void load(const ResourceRequest&, const String& frameName, bool lockHistory);                                 // Called by WebPluginController
136         
137         void loadArchive(PassRefPtr<Archive> archive);
138
139         // Returns true for any non-local URL. If Document parameter is supplied, its local load policy dictates,
140         // otherwise if referrer is non-empty and represents a local file, then the local load is allowed.
141         static bool canLoad(const KURL&, const String& referrer, const Document* theDocument = 0);
142         static void reportLocalLoadFailed(Frame*, const String& url);
143
144         static bool shouldHideReferrer(const KURL&, const String& referrer);
145
146         // Called by createWindow in JSDOMWindowBase.cpp, e.g. to fulfill a modal dialog creation
147         Frame* createWindow(FrameLoader* frameLoaderForFrameLookup, const FrameLoadRequest&, const WindowFeatures&, bool& created);
148
149         unsigned long loadResourceSynchronously(const ResourceRequest&, ResourceError&, ResourceResponse&, Vector<char>& data);
150
151         bool canHandleRequest(const ResourceRequest&);
152
153         // Also not cool.
154         void stopAllLoaders();
155         void stopForUserCancel(bool deferCheckLoadComplete = false);
156
157         bool isLoadingMainResource() const { return m_isLoadingMainResource; }
158         bool isLoading() const;
159         bool frameHasLoaded() const;
160
161         int numPendingOrLoadingRequests(bool recurse) const;
162         String referrer() const;
163         String outgoingReferrer() const;
164         String outgoingOrigin() const;
165         void loadEmptyDocumentSynchronously();
166
167         DocumentLoader* activeDocumentLoader() const;
168         DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
169         DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
170         DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
171         FrameState state() const { return m_state; }
172         static double timeOfLastCompletedLoad();
173
174         bool shouldUseCredentialStorage(ResourceLoader*);
175         void didReceiveAuthenticationChallenge(ResourceLoader*, const AuthenticationChallenge&);
176         void didCancelAuthenticationChallenge(ResourceLoader*, const AuthenticationChallenge&);
177         
178         void assignIdentifierToInitialRequest(unsigned long identifier, const ResourceRequest&);
179         void willSendRequest(ResourceLoader*, ResourceRequest&, const ResourceResponse& redirectResponse);
180         void didReceiveResponse(ResourceLoader*, const ResourceResponse&);
181         void didReceiveData(ResourceLoader*, const char*, int, int lengthReceived);
182         void didFinishLoad(ResourceLoader*);
183         void didFailToLoad(ResourceLoader*, const ResourceError&);
184         const ResourceRequest& originalRequest() const;
185         const ResourceRequest& initialRequest() const;
186         void receivedMainResourceError(const ResourceError&, bool isComplete);
187         void receivedData(const char*, int);
188
189         void handleFallbackContent();
190         bool isStopping() const;
191
192         void finishedLoading();
193
194         ResourceError cancelledError(const ResourceRequest&) const;
195         ResourceError fileDoesNotExistError(const ResourceResponse&) const;
196         ResourceError blockedError(const ResourceRequest&) const;
197         ResourceError cannotShowURLError(const ResourceRequest&) const;
198
199         void cannotShowMIMEType(const ResourceResponse&);
200         ResourceError interruptionForPolicyChangeError(const ResourceRequest&);
201
202         bool isHostedByObjectElement() const;
203         bool isLoadingMainFrame() const;
204         bool canShowMIMEType(const String& MIMEType) const;
205         bool representationExistsForURLScheme(const String& URLScheme);
206         String generatedMIMETypeForURLScheme(const String& URLScheme);
207
208         void notifyIconChanged();
209
210         void checkNavigationPolicy(const ResourceRequest&, NavigationPolicyDecisionFunction function, void* argument);
211         void checkContentPolicy(const String& MIMEType, ContentPolicyDecisionFunction, void* argument);
212         void cancelContentPolicyCheck();
213
214         void reload(bool endToEndReload = false);
215         void reloadWithOverrideEncoding(const String& overrideEncoding);
216
217         void didReceiveServerRedirectForProvisionalLoadForFrame();
218         void finishedLoadingDocument(DocumentLoader*);
219         void committedLoad(DocumentLoader*, const char*, int);
220         bool isReplacing() const;
221         void setReplacing();
222         void revertToProvisional(DocumentLoader*);
223         void setMainDocumentError(DocumentLoader*, const ResourceError&);
224         void mainReceivedCompleteError(DocumentLoader*, const ResourceError&);
225         bool subframeIsLoading() const;
226         void willChangeTitle(DocumentLoader*);
227         void didChangeTitle(DocumentLoader*);
228
229         FrameLoadType loadType() const;
230         CachePolicy cachePolicy() const;
231
232         void didFirstLayout();
233         bool firstLayoutDone() const;
234
235         void didFirstVisuallyNonEmptyLayout();
236
237 #if ENABLE(WML)
238         void setForceReloadWmlDeck(bool);
239 #endif
240
241         void loadedResourceFromMemoryCache(const CachedResource*);
242         void tellClientAboutPastMemoryCacheLoads();
243
244         void checkLoadComplete();
245         void detachFromParent();
246
247         void addExtraFieldsToSubresourceRequest(ResourceRequest&);
248         void addExtraFieldsToMainResourceRequest(ResourceRequest&);
249         
250         static void addHTTPOriginIfNeeded(ResourceRequest&, String origin);
251
252         FrameLoaderClient* client() const { return m_client; }
253
254         void setDefersLoading(bool);
255
256         void changeLocation(const KURL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool userGesture = false, bool refresh = false);
257         void urlSelected(const ResourceRequest&, const String& target, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, bool userGesture);
258       
259         bool requestFrame(HTMLFrameOwnerElement*, const String& url, const AtomicString& frameName);
260
261         void submitForm(const char* action, const String& url, PassRefPtr<FormData>, const String& target, const String& contentType, const String& boundary, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList);
262
263         void stop();
264         void stopLoading(bool sendUnload);
265
266         void didExplicitOpen();
267
268         KURL iconURL();
269         void commitIconURLToIconDatabase(const KURL&);
270
271         KURL baseURL() const;
272
273         bool isScheduledLocationChangePending() const { return m_scheduledRedirection && isLocationChange(*m_scheduledRedirection); }
274         void scheduleHTTPRedirection(double delay, const String& url);
275         void scheduleLocationChange(const String& url, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool userGesture = false);
276         void scheduleRefresh(bool userGesture = false);
277         void scheduleHistoryNavigation(int steps);
278
279         bool canGoBackOrForward(int distance) const;
280         void goBackOrForward(int distance);
281         int getHistoryLength();
282
283         void begin();
284         void begin(const KURL&, bool dispatchWindowObjectAvailable = true, SecurityOrigin* forcedSecurityOrigin = 0);
285
286         void write(const char* string, int length = -1, bool flush = false);
287         void write(const String&);
288         void end();
289         void endIfNotLoadingMainResource();
290
291         void setEncoding(const String& encoding, bool userChosen);
292         String encoding() const;
293
294         ScriptValue executeScript(const ScriptSourceCode&);
295         ScriptValue executeScript(const String& script, bool forceUserGesture = false);
296
297         void gotoAnchor();
298
299         void tokenizerProcessedData();
300
301         void handledOnloadEvents();
302         String userAgent(const KURL&) const;
303
304         Widget* createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const HashMap<String, String>& args);
305
306         void dispatchWindowObjectAvailable();
307         void dispatchDocumentElementAvailable();
308         void restoreDocumentState();
309
310         Frame* opener();
311         void setOpener(Frame*);
312         bool openedByDOM() const;
313         void setOpenedByDOM();
314
315         bool userGestureHint();
316
317         void resetMultipleFormSubmissionProtection();
318
319         void addData(const char* bytes, int length);
320
321         void checkCallImplicitClose();
322
323         void frameDetached();
324
325         const KURL& url() const { return m_URL; }
326
327         void updateBaseURLForEmptyDocument();
328
329         void setResponseMIMEType(const String&);
330         const String& responseMIMEType() const;
331
332         bool containsPlugins() const;
333
334         void loadDone();
335         void finishedParsing();
336         void checkCompleted();
337
338         void clearRecordedFormValues();
339         void setFormAboutToBeSubmitted(PassRefPtr<HTMLFormElement> element);
340         void recordFormValue(const String& name, const String& value);
341
342         bool isComplete() const;
343
344         bool requestObject(RenderPart* frame, const String& url, const AtomicString& frameName,
345             const String& serviceType, const Vector<String>& paramNames, const Vector<String>& paramValues);
346
347         KURL completeURL(const String& url);
348
349         void cancelAndClear();
350
351         void setTitle(const String&);
352
353         void commitProvisionalLoad(PassRefPtr<CachedPage>);
354
355         void goToItem(HistoryItem*, FrameLoadType);
356         void saveDocumentAndScrollState();
357
358         HistoryItem* currentHistoryItem();
359
360         enum LocalLoadPolicy {
361             AllowLocalLoadsForAll,  // No restriction on local loads.
362             AllowLocalLoadsForLocalAndSubstituteData,
363             AllowLocalLoadsForLocalOnly,
364         };
365         static void setLocalLoadPolicy(LocalLoadPolicy);
366         static bool restrictAccessToLocal();
367         static bool allowSubstituteDataAccessToLocal();
368
369         static void registerURLSchemeAsLocal(const String&);
370         static bool shouldTreatURLAsLocal(const String&);
371         static bool shouldTreatURLSchemeAsLocal(const String&);
372
373         static void registerURLSchemeAsNoAccess(const String&);
374         static bool shouldTreatURLSchemeAsNoAccess(const String&);
375
376         bool committingFirstRealLoad() const { return !m_creatingInitialEmptyDocument && !m_committedFirstRealDocumentLoad; }
377
378         void iconLoadDecisionAvailable();
379
380         bool shouldAllowNavigation(Frame* targetFrame) const;
381         Frame* findFrameForNavigation(const AtomicString& name);
382
383         void startIconLoader();
384
385         void applyUserAgent(ResourceRequest& request);
386
387     private:
388         PassRefPtr<HistoryItem> createHistoryItem(bool useOriginal);
389         PassRefPtr<HistoryItem> createHistoryItemTree(Frame* targetFrame, bool clipAtTarget);
390
391         bool canCachePageContainingThisFrame();
392 #ifndef NDEBUG
393         void logCanCachePageDecision();
394         bool logCanCacheFrameDecision(int indentLevel);
395 #endif
396
397         void addBackForwardItemClippedAtTarget(bool doClip);
398         void restoreScrollPositionAndViewState();
399         void saveDocumentState();
400         void loadItem(HistoryItem*, FrameLoadType);
401         bool urlsMatchItem(HistoryItem*) const;
402         void invalidateCurrentItemCachedPage();
403         void recursiveGoToItem(HistoryItem*, HistoryItem*, FrameLoadType);
404         bool childFramesMatchItem(HistoryItem*) const;
405
406         void updateHistoryForBackForwardNavigation();
407         void updateHistoryForReload();
408         void updateHistoryForStandardLoad();
409         void updateHistoryForRedirectWithLockedBackForwardList();
410         void updateHistoryForClientRedirect();
411         void updateHistoryForCommit();
412         void updateHistoryForAnchorScroll();
413     
414         void redirectionTimerFired(Timer<FrameLoader>*);
415         void checkCompletedTimerFired(Timer<FrameLoader>*);
416         void checkLoadCompleteTimerFired(Timer<FrameLoader>*);
417         
418         void cancelRedirection(bool newLoadInProgress = false);
419
420         void started();
421
422         void completed();
423         void parentCompleted();
424
425         bool shouldUsePlugin(const KURL&, const String& mimeType, bool hasFallback, bool& useFallback);
426         bool loadPlugin(RenderPart*, const KURL&, const String& mimeType,
427         const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback);
428         
429         bool loadProvisionalItemFromCachedPage();
430         void cachePageForHistoryItem(HistoryItem*);
431
432         void receivedFirstData();
433
434         void updatePolicyBaseURL();
435         void setPolicyBaseURL(const KURL&);
436         
437         void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType loadType, bool isMainResource, bool cookiePolicyURLFromRequest);
438
439         // Also not cool.
440         void stopLoadingSubframes();
441
442         void clearProvisionalLoad();
443         void markLoadComplete();
444         void transitionToCommitted(PassRefPtr<CachedPage>);
445         void frameLoadCompleted();
446
447         void mainReceivedError(const ResourceError&, bool isComplete);
448
449         void setLoadType(FrameLoadType);
450
451         void checkNavigationPolicy(const ResourceRequest&, DocumentLoader*, PassRefPtr<FormState>, NavigationPolicyDecisionFunction, void* argument);
452         void checkNewWindowPolicy(const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName);
453
454         void continueAfterNavigationPolicy(PolicyAction);
455         void continueAfterNewWindowPolicy(PolicyAction);
456         void continueAfterContentPolicy(PolicyAction);
457         void continueLoadAfterWillSubmitForm(PolicyAction = PolicyUse);
458
459         static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
460         void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
461         static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
462         void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
463         static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
464         void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
465         bool shouldScrollToAnchor(bool isFormSubmission, FrameLoadType, const KURL&);
466         void addHistoryItemForFragmentScroll();
467
468         void stopPolicyCheck();
469
470         void checkLoadCompleteForThisFrame();
471
472         void setDocumentLoader(DocumentLoader*);
473         void setPolicyDocumentLoader(DocumentLoader*);
474         void setProvisionalDocumentLoader(DocumentLoader*);
475
476         void setState(FrameState);
477
478         void closeOldDataSources();
479         void open(CachedPage&);
480         void open(CachedFrame&);
481
482         void updateHistoryAfterClientRedirect();
483
484         void clear(bool clearWindowProperties = true, bool clearScriptObjects = true);
485
486         bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
487         void handleUnimplementablePolicy(const ResourceError&);
488
489         void scheduleRedirection(ScheduledRedirection*);
490         void startRedirectionTimer();
491         void stopRedirectionTimer();
492
493         void dispatchDidCommitLoad();
494         void dispatchAssignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&);
495         void dispatchWillSendRequest(DocumentLoader*, unsigned long identifier, ResourceRequest&, const ResourceResponse& redirectResponse);
496         void dispatchDidReceiveResponse(DocumentLoader*, unsigned long identifier, const ResourceResponse&);
497         void dispatchDidReceiveContentLength(DocumentLoader*, unsigned long identifier, int length);
498         void dispatchDidFinishLoading(DocumentLoader*, unsigned long identifier);
499
500         static bool isLocationChange(const ScheduledRedirection&);
501
502         void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>);         // Calls continueLoadAfterNavigationPolicy
503         void load(DocumentLoader*);                                                                 // Calls loadWithDocumentLoader   
504
505         void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&,              // Calls loadWithDocumentLoader()
506             bool lockHistory, FrameLoadType, PassRefPtr<FormState>);
507
508         void loadPostRequest(const ResourceRequest&, const String& referrer,                        // Called by loadFrameRequestWithFormAndValues(), calls loadWithNavigationAction
509             const String& frameName, bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
510
511         void loadURL(const KURL& newURL, const String& referrer, const String& frameName,           // Called by loadFrameRequestWithFormAndValues(), calls loadWithNavigationAction or else dispatches to navigation policy delegate    
512             bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);                                                         
513
514         void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
515         void clientRedirected(const KURL&, double delay, double fireDate, bool lockBackForwardList, bool isJavaScriptFormAction);
516         bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
517
518         void sendRemainingDelegateMessages(unsigned long identifier, const ResourceResponse&, int length, const ResourceError&);
519         void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
520
521         void recursiveCheckLoadComplete();
522
523         void detachChildren();
524         void closeAndRemoveChild(Frame*);
525
526         Frame* loadSubframe(HTMLFrameOwnerElement*, const KURL&, const String& name, const String& referrer);
527
528         void submitFormAgain();
529         void submitForm(const FrameLoadRequest&, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList);
530
531         bool closeURL();
532
533         KURL historyURL(int distance);
534
535         // Returns true if argument is a JavaScript URL.
536         bool executeIfJavaScriptURL(const KURL&, bool userGesture = false, bool replaceDocument = true);
537
538         bool gotoAnchor(const String& name); // returns true if the anchor was found
539         void scrollToAnchor(const KURL&);
540
541         void provisionalLoadStarted();
542
543         bool canCachePage();
544
545         bool didOpenURL(const KURL&);
546
547         void scheduleCheckCompleted();
548         void scheduleCheckLoadComplete();
549
550         KURL originalRequestURL() const;
551
552         bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
553
554         void saveScrollPositionAndViewStateToItem(HistoryItem*);
555
556         Frame* m_frame;
557         FrameLoaderClient* m_client;
558
559         FrameState m_state;
560         FrameLoadType m_loadType;
561
562         // Document loaders for the three phases of frame loading. Note that while 
563         // a new request is being loaded, the old document loader may still be referenced.
564         // E.g. while a new request is in the "policy" state, the old document loader may
565         // be consulted in particular as it makes sense to imply certain settings on the new loader.
566         RefPtr<DocumentLoader> m_documentLoader;
567         RefPtr<DocumentLoader> m_provisionalDocumentLoader;
568         RefPtr<DocumentLoader> m_policyDocumentLoader;
569
570         // This identifies the type of navigation action which prompted this load. Note 
571         // that WebKit conveys this value as the WebActionNavigationTypeKey value
572         // on navigation action delegate callbacks.
573         FrameLoadType m_policyLoadType;
574         PolicyCheck m_policyCheck;
575
576         bool m_delegateIsHandlingProvisionalLoadError;
577         bool m_delegateIsDecidingNavigationPolicy;
578         bool m_delegateIsHandlingUnimplementablePolicy;
579
580         bool m_firstLayoutDone;
581         bool m_quickRedirectComing;
582         bool m_sentRedirectNotification;
583         bool m_inStopAllLoaders;
584         bool m_navigationDuringLoad;
585
586         String m_outgoingReferrer;
587
588         OwnPtr<FormSubmission> m_deferredFormSubmission;
589
590         bool m_isExecutingJavaScriptFormAction;
591         bool m_isRunningScript;
592
593         String m_responseMIMEType;
594
595         bool m_didCallImplicitClose;
596         bool m_wasUnloadEventEmitted;
597         bool m_isComplete;
598         bool m_isLoadingMainResource;
599
600         KURL m_URL;
601         KURL m_workingURL;
602
603         OwnPtr<IconLoader> m_iconLoader;
604         bool m_mayLoadIconLater;
605
606         bool m_cancellingWithLoadInProgress;
607
608         OwnPtr<ScheduledRedirection> m_scheduledRedirection;
609
610         bool m_needsClear;
611         bool m_receivedData;
612
613         bool m_encodingWasChosenByUser;
614         String m_encoding;
615         RefPtr<TextResourceDecoder> m_decoder;
616
617         bool m_containsPlugIns;
618
619         RefPtr<HTMLFormElement> m_formAboutToBeSubmitted;
620         HashMap<String, String> m_formValuesAboutToBeSubmitted;
621         KURL m_submittedFormURL;
622     
623         Timer<FrameLoader> m_redirectionTimer;
624         Timer<FrameLoader> m_checkCompletedTimer;
625         Timer<FrameLoader> m_checkLoadCompleteTimer;
626
627         Frame* m_opener;
628         HashSet<Frame*> m_openedFrames;
629
630         bool m_openedByDOM;
631
632         bool m_creatingInitialEmptyDocument;
633         bool m_isDisplayingInitialEmptyDocument;
634         bool m_committedFirstRealDocumentLoad;
635
636         RefPtr<HistoryItem> m_currentHistoryItem;
637         RefPtr<HistoryItem> m_previousHistoryItem;
638         RefPtr<HistoryItem> m_provisionalHistoryItem;
639         
640         bool m_didPerformFirstNavigation;
641         
642 #ifndef NDEBUG
643         bool m_didDispatchDidCommitLoad;
644 #endif
645
646 #if ENABLE(WML)
647         bool m_forceReloadWmlDeck;
648 #endif
649     };
650
651 } // namespace WebCore
652
653 #endif // FrameLoader_h