0b5f1c8251cc7cce5e9869ceb6e740dde1ec27de
[WebKit-https.git] / WebCore / loader / FrameLoader.h
1 /*
2  * Copyright (C) 2006, 2007 Apple 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 #ifndef FrameLoader_h
30 #define FrameLoader_h
31
32 #include "CachedResource.h"
33 #include "CachePolicy.h"
34 #include "FormState.h"
35 #include "FrameLoaderTypes.h"
36 #include "KURL.h"
37 #include "StringHash.h"
38 #include "Timer.h"
39 #include <wtf/Forward.h>
40 #include <wtf/HashSet.h>
41 #include <wtf/HashMap.h>
42 #include <wtf/Noncopyable.h>
43 #include <wtf/OwnPtr.h>
44 #include <wtf/RefPtr.h>
45 #include "ResourceRequest.h"
46 #if USE(LOW_BANDWIDTH_DISPLAY)
47 #include "CachedResourceClient.h"
48 #endif
49
50 namespace KJS {
51     class JSValue;
52 }
53
54 namespace WebCore {
55
56     class AuthenticationChallenge;
57     class CachedPage;
58     class Document;
59     class DocumentLoader;
60     class Element;
61     class Event;
62     class FormData;
63     class Frame;
64     class FrameLoaderClient;
65     class HistoryItem;
66     class HTMLFormElement;
67     class HTMLFrameOwnerElement;
68     class IconLoader;
69     class IntSize;
70     class NavigationAction;
71     class Node;
72     class Page;
73     class RenderPart;
74     class ResourceError;
75     class ResourceLoader;
76     class ResourceRequest;
77     class ResourceResponse;
78     class SharedBuffer;
79     class SubstituteData;
80     class TextResourceDecoder;
81     class Widget;
82
83     struct FormSubmission;
84     struct FrameLoadRequest;
85     struct ScheduledRedirection;
86     struct WindowFeatures;
87
88     bool isBackForwardLoadType(FrameLoadType);
89
90     typedef void (*NavigationPolicyDecisionFunction)(void* argument,
91         const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
92     typedef void (*NewWindowPolicyDecisionFunction)(void* argument,
93         const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
94     typedef void (*ContentPolicyDecisionFunction)(void* argument, PolicyAction);
95
96     class PolicyCheck {
97     public:
98         PolicyCheck();
99
100         void clear();
101         void set(const ResourceRequest&, PassRefPtr<FormState>,
102             NavigationPolicyDecisionFunction, void* argument);
103         void set(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName,
104             NewWindowPolicyDecisionFunction, void* argument);
105         void set(ContentPolicyDecisionFunction, void* argument);
106
107         const ResourceRequest& request() const { return m_request; }
108         void clearRequest();
109
110         void call(bool shouldContinue);
111         void call(PolicyAction);
112         void cancel();
113
114     private:
115         ResourceRequest m_request;
116         RefPtr<FormState> m_formState;
117         String m_frameName;
118
119         NavigationPolicyDecisionFunction m_navigationFunction;
120         NewWindowPolicyDecisionFunction m_newWindowFunction;
121         ContentPolicyDecisionFunction m_contentFunction;
122         void* m_argument;
123     };
124
125     class FrameLoader : Noncopyable
126 #if USE(LOW_BANDWIDTH_DISPLAY)
127     , private CachedResourceClient
128 #endif
129     {
130     public:
131         FrameLoader(Frame*, FrameLoaderClient*);
132         ~FrameLoader();
133
134         void init();
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         void load(const KURL&, Event*);
144         void load(const FrameLoadRequest&, bool lockHistory, bool userGesture,
145             Event*, HTMLFormElement*, const HashMap<String, String>& formValues);
146         void load(const KURL&, const String& referrer, FrameLoadType, const String& target,
147             Event*, PassRefPtr<FormState>);
148         void post(const KURL&, const String& referrer, const String& target,
149             PassRefPtr<FormData>, const String& contentType,
150             Event*, HTMLFormElement*, const HashMap<String, String>& formValues);
151
152         void load(const ResourceRequest&);
153         void load(const ResourceRequest&, const SubstituteData&);
154         void load(const ResourceRequest&, const String& frameName);
155         void load(const ResourceRequest&, const NavigationAction&, FrameLoadType, PassRefPtr<FormState>);
156         
157         void load(DocumentLoader*);
158         void load(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>);
159
160         static bool canLoad(const KURL&, const String& referrer);
161         static bool canLoad(const KURL&, const Document*);
162         static bool canLoad(const CachedResource&, const Document*);
163         static void reportLocalLoadFailed(const Page*, const String& url);
164
165         static bool shouldHideReferrer(const KURL& url, const String& referrer);
166
167         Frame* createWindow(const FrameLoadRequest&, const WindowFeatures&, bool& created);
168
169         void loadResourceSynchronously(const ResourceRequest&, ResourceError&, ResourceResponse&, Vector<char>& data);
170
171         bool canHandleRequest(const ResourceRequest&);
172
173         // Also not cool.
174         void stopAllLoaders();
175         void stopForUserCancel(bool deferCheckLoadComplete = false);
176         void cancelPendingArchiveLoad(ResourceLoader*);
177
178         bool isLoadingMainResource() const { return m_isLoadingMainResource; }
179         bool isLoading() const;
180         bool frameHasLoaded() const;
181         bool committedFirstRealDocumentLoad() const { return m_committedFirstRealDocumentLoad; }
182
183         int numPendingOrLoadingRequests(bool recurse) const;
184         bool isReloading() const;
185         String referrer() const;
186         String outgoingReferrer() const;
187         void loadEmptyDocumentSynchronously();
188
189         DocumentLoader* activeDocumentLoader() const;
190         DocumentLoader* documentLoader() const;
191         DocumentLoader* provisionalDocumentLoader();
192         FrameState state() const;
193         static double timeOfLastCompletedLoad();
194         
195         void didReceiveAuthenticationChallenge(ResourceLoader*, const AuthenticationChallenge&);
196         void didCancelAuthenticationChallenge(ResourceLoader*, const AuthenticationChallenge&);
197         
198         void assignIdentifierToInitialRequest(unsigned long identifier, const ResourceRequest&);
199         void willSendRequest(ResourceLoader*, ResourceRequest&, const ResourceResponse& redirectResponse);
200         void didReceiveResponse(ResourceLoader*, const ResourceResponse&);
201         void didReceiveData(ResourceLoader*, const char*, int, int lengthReceived);
202         void didFinishLoad(ResourceLoader*);
203         void didFailToLoad(ResourceLoader*, const ResourceError&);
204         bool privateBrowsingEnabled() const;
205         const ResourceRequest& originalRequest() const;
206         const ResourceRequest& initialRequest() const;
207         void receivedMainResourceError(const ResourceError&, bool isComplete);
208         void receivedData(const char*, int);
209
210         void handleFallbackContent();
211         bool isStopping() const;
212
213         void finishedLoading();
214
215         ResourceError cancelledError(const ResourceRequest&) const;
216         ResourceError fileDoesNotExistError(const ResourceResponse&) const;
217         ResourceError blockedError(const ResourceRequest&) const;
218         bool willUseArchive(ResourceLoader*, const ResourceRequest&, const KURL&) const;
219         bool isArchiveLoadPending(ResourceLoader*) const;
220         void cannotShowMIMEType(const ResourceResponse&);
221         ResourceError interruptionForPolicyChangeError(const ResourceRequest&);
222
223         bool isHostedByObjectElement() const;
224         bool isLoadingMainFrame() const;
225         bool canShowMIMEType(const String& MIMEType) const;
226         bool representationExistsForURLScheme(const String& URLScheme);
227         String generatedMIMETypeForURLScheme(const String& URLScheme);
228
229         void notifyIconChanged();
230
231         void checkNavigationPolicy(const ResourceRequest&, NavigationPolicyDecisionFunction function, void* argument);
232         void checkContentPolicy(const String& MIMEType, ContentPolicyDecisionFunction, void* argument);
233         void cancelContentPolicyCheck();
234
235         void reload();
236         void reloadAllowingStaleData(const String& overrideEncoding);
237
238         void didReceiveServerRedirectForProvisionalLoadForFrame();
239         void finishedLoadingDocument(DocumentLoader*);
240         void committedLoad(DocumentLoader*, const char*, int);
241         bool isReplacing() const;
242         void setReplacing();
243         void revertToProvisional(DocumentLoader*);
244         void setMainDocumentError(DocumentLoader*, const ResourceError&);
245         void mainReceivedCompleteError(DocumentLoader*, const ResourceError&);
246         bool subframeIsLoading() const;
247         void willChangeTitle(DocumentLoader*);
248         void didChangeTitle(DocumentLoader*);
249
250         FrameLoadType loadType() const;
251
252         void didFirstLayout();
253         bool firstLayoutDone() const;
254
255         void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
256         void clientRedirected(const KURL&, double delay, double fireDate, bool lockHistory, bool isJavaScriptFormAction);
257         bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
258
259         bool isQuickRedirectComing() const;
260
261         void sendRemainingDelegateMessages(unsigned long identifier, const ResourceResponse&, int length, const ResourceError&);
262         void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
263         void loadedResourceFromMemoryCache(const ResourceRequest&, const ResourceResponse&, int length);
264
265         void recursiveCheckLoadComplete();
266         void checkLoadComplete();
267         void detachFromParent();
268         void detachChildren();
269
270         void addExtraFieldsToRequest(ResourceRequest&, bool isMainResource, bool alwaysFromRequest);
271
272         FrameLoaderClient* client() const;
273
274         void setDefersLoading(bool);
275
276         void changeLocation(const String& URL, const String& referrer, bool lockHistory = true, bool userGesture = false);
277         void changeLocation(const KURL& URL, const String& referrer, bool lockHistory = true, bool userGesture = false);
278         void urlSelected(const ResourceRequest&, const String& target, Event*, bool lockHistory, bool userGesture);
279         void urlSelected(const FrameLoadRequest&, Event*, bool lockHistory, bool userGesture);
280       
281         bool requestFrame(HTMLFrameOwnerElement*, const String& URL, const AtomicString& frameName);
282         Frame* loadSubframe(HTMLFrameOwnerElement*, const KURL& URL, const String& name, const String& referrer);
283
284         void submitForm(const char* action, const String& URL, PassRefPtr<FormData>, const String& target, const String& contentType, const String& boundary, Event*);
285         void submitFormAgain();
286         void submitForm(const FrameLoadRequest&, Event*);
287
288         void stop();
289         void stopLoading(bool sendUnload);
290         bool closeURL();
291
292         void didExplicitOpen();
293
294         KURL iconURL();
295         void commitIconURLToIconDatabase(const KURL&);
296
297         KURL baseURL() const;
298         String baseTarget() const;
299         KURL dataURLBaseFromRequest(const ResourceRequest& request) const;
300
301         bool isScheduledLocationChangePending() const { return m_scheduledRedirection && isLocationChange(*m_scheduledRedirection); }
302         void scheduleHTTPRedirection(double delay, const String& URL);
303         void scheduleLocationChange(const String& URL, const String& referrer, bool lockHistory = true, bool userGesture = false);
304         void scheduleRefresh(bool userGesture = false);
305         void scheduleHistoryNavigation(int steps);
306
307         bool canGoBackOrForward(int distance) const;
308         void goBackOrForward(int distance);
309         int getHistoryLength();
310         KURL historyURL(int distance);
311
312         void begin();
313         void begin(const KURL&, bool dispatchWindowObjectAvailable = true);
314
315         void write(const char* str, int len = -1, bool flush = false);
316         void write(const String&);
317         void end();
318         void endIfNotLoadingMainResource();
319
320         void setEncoding(const String& encoding, bool userChosen);
321         String encoding() const;
322
323         KJS::JSValue* executeScript(const String& URL, int baseLine, const String& script);
324         KJS::JSValue* executeScript(const String& script, bool forceUserGesture = false);
325
326         void gotoAnchor();
327         bool gotoAnchor(const String& name); // returns true if the anchor was found
328         void scrollToAnchor(const KURL&);
329
330         void tokenizerProcessedData();
331
332         void handledOnloadEvents();
333         String userAgent(const KURL&) const;
334
335         Widget* createJavaAppletWidget(const IntSize&, Element*, const HashMap<String, String>& args);
336
337         void dispatchWindowObjectAvailable();
338         void restoreDocumentState();
339
340         Frame* opener();
341         void setOpener(Frame*);
342         bool openedByDOM() const;
343         void setOpenedByDOM();
344
345         void provisionalLoadStarted();
346
347         bool userGestureHint();
348
349         void resetMultipleFormSubmissionProtection();
350         void didNotOpenURL(const KURL&);
351
352         void addData(const char* bytes, int length);
353
354         bool canCachePage();
355
356         void checkCallImplicitClose();
357         bool didOpenURL(const KURL&);
358
359         void frameDetached();
360
361         // FIXME: Which one of these URL methods is right?
362         KURL url() const;
363         KURL URL() const;
364
365         void updateBaseURLForEmptyDocument();
366
367         void setResponseMIMEType(const String&);
368         const String& responseMIMEType() const;
369
370         bool containsPlugins() const;
371
372         void loadDone();
373         void finishedParsing();
374         void checkCompleted();
375         void scheduleCheckCompleted();
376         void scheduleCheckLoadComplete();
377
378         void clearRecordedFormValues();
379         void recordFormValue(const String& name, const String& value, PassRefPtr<HTMLFormElement>);
380
381         bool isComplete() const;
382
383         bool requestObject(RenderPart* frame, const String& URL, const AtomicString& frameName,
384             const String& serviceType, const Vector<String>& paramNames, const Vector<String>& paramValues);
385
386         KURL completeURL(const String& URL);
387
388         void didTellBridgeAboutLoad(const String& URL);
389         bool haveToldBridgeAboutLoad(const String& URL);
390
391         KURL originalRequestURL() const;
392
393         void cancelAndClear();
394
395         void setTitle(const String&);
396         void dispatchDidChangeLocationWithinPage();
397         
398         void dispatchDidFinishLoadToClient();
399         void updateGlobalHistoryForStandardLoad(const KURL&);
400         void updateGlobalHistoryForReload(const KURL&);
401         bool shouldGoToHistoryItem(HistoryItem*) const;
402         bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
403
404         void commitProvisionalLoad(PassRefPtr<CachedPage>);
405
406         void goToItem(HistoryItem*, FrameLoadType);
407         void saveDocumentAndScrollState();
408         void saveScrollPositionAndViewStateToItem(HistoryItem*);
409
410         // FIXME: These accessors are here for a dwindling number of users in WebKit, WebFrame
411         // being the primary one.  After they're no longer needed there, they can be removed!
412         HistoryItem* currentHistoryItem();
413         HistoryItem* previousHistoryItem();
414         HistoryItem* provisionalHistoryItem();
415         void setCurrentHistoryItem(PassRefPtr<HistoryItem>);
416         void setPreviousHistoryItem(PassRefPtr<HistoryItem>);
417         void setProvisionalHistoryItem(PassRefPtr<HistoryItem>);
418
419         void continueLoadWithData(SharedBuffer*, const String& mimeType, const String& textEncoding, const KURL&); 
420
421         static void registerURLSchemeAsLocal(const String& scheme);
422         static bool restrictAccessToLocal();
423         static void setRestrictAccessToLocal(bool);
424         static bool shouldTreatURLAsLocal(const String&);
425         static bool shouldTreatSchemeAsLocal(const String&);
426
427 #if USE(LOW_BANDWIDTH_DISPLAY)    
428         bool addLowBandwidthDisplayRequest(CachedResource*);
429         void needToSwitchOutLowBandwidthDisplay() { m_needToSwitchOutLowBandwidthDisplay = true; }
430
431         // Client can control whether to use low bandwidth display on a per frame basis.
432         // However, this should only be used for the top frame, not sub-frame.
433         void setUseLowBandwidthDisplay(bool lowBandwidth) { m_useLowBandwidthDisplay = lowBandwidth; }
434         bool useLowBandwidthDisplay() const { return m_useLowBandwidthDisplay; }
435 #endif
436
437         bool committingFirstRealLoad() const { return !m_creatingInitialEmptyDocument && !m_committedFirstRealDocumentLoad; }
438
439         void iconLoadDecisionAvailable();
440
441         bool shouldAllowNavigation(Frame* targetFrame) const;
442
443     private:
444         PassRefPtr<HistoryItem> createHistoryItem(bool useOriginal);
445         PassRefPtr<HistoryItem> createHistoryItemTree(Frame* targetFrame, bool clipAtTarget);
446
447         void addBackForwardItemClippedAtTarget(bool doClip);
448         void restoreScrollPositionAndViewState();
449         void saveDocumentState();
450         void loadItem(HistoryItem*, FrameLoadType);
451         bool urlsMatchItem(HistoryItem*) const;
452         void invalidateCurrentItemCachedPage();
453         void recursiveGoToItem(HistoryItem*, HistoryItem*, FrameLoadType);
454         bool childFramesMatchItem(HistoryItem*) const;
455
456         void addHistoryForCurrentLocation();
457         void updateHistoryForBackForwardNavigation();
458         void updateHistoryForReload();
459         void updateHistoryForStandardLoad();
460         void updateHistoryForRedirectWithLockedHistory();
461         void updateHistoryForClientRedirect();
462         void updateHistoryForCommit();
463     
464         void redirectionTimerFired(Timer<FrameLoader>*);
465         void checkCompletedTimerFired(Timer<FrameLoader>*);
466         void checkLoadCompleteTimerFired(Timer<FrameLoader>*);
467
468         void cancelRedirection(bool newLoadInProgress = false);
469
470         void started();
471
472         void completed();
473         void parentCompleted();
474
475         bool shouldUsePlugin(const KURL&, const String& mimeType, bool hasFallback, bool& useFallback);
476         bool loadPlugin(RenderPart*, const KURL&, const String& mimeType,
477         const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback);
478         
479         bool loadProvisionalItemFromCachedPage();
480         void cachePageForHistoryItem(HistoryItem*);
481
482         void receivedFirstData();
483
484         void updatePolicyBaseURL();
485         void setPolicyBaseURL(const String&);
486
487         void replaceContentsWithScriptResult(const KURL&);
488
489         // Also not cool.
490         void stopLoadingSubframes();
491
492         void clearProvisionalLoad();
493         void markLoadComplete();
494         void transitionToCommitted(PassRefPtr<CachedPage>);
495         void frameLoadCompleted();
496
497         void mainReceivedError(const ResourceError&, bool isComplete);
498
499         void setLoadType(FrameLoadType);
500
501         void checkNavigationPolicy(const ResourceRequest&, DocumentLoader*, PassRefPtr<FormState>,
502                                    NavigationPolicyDecisionFunction, void* argument);
503         void checkNewWindowPolicy(const NavigationAction&, const ResourceRequest&, 
504                                   PassRefPtr<FormState>, const String& frameName);
505
506         void continueAfterNavigationPolicy(PolicyAction);
507         void continueAfterNewWindowPolicy(PolicyAction);
508         void continueAfterContentPolicy(PolicyAction);
509         void continueLoadAfterWillSubmitForm(PolicyAction = PolicyUse);
510
511         static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
512         void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
513         static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
514         void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
515         static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
516         void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
517         void addHistoryItemForFragmentScroll();
518
519         void stopPolicyCheck();
520
521         void closeDocument();
522         
523         void checkLoadCompleteForThisFrame();
524
525         void setDocumentLoader(DocumentLoader*);
526         void setPolicyDocumentLoader(DocumentLoader*);
527         void setProvisionalDocumentLoader(DocumentLoader*);
528
529         void setState(FrameState);
530
531         void closeOldDataSources();
532         void open(CachedPage&);
533         void opened();
534         void updateHistoryAfterClientRedirect();
535
536         void clear(bool clearWindowProperties = true, bool clearScriptObjects = true);
537
538         bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
539         void handleUnimplementablePolicy(const ResourceError&);
540
541         void applyUserAgent(ResourceRequest& request);
542
543         void scheduleRedirection(ScheduledRedirection*);
544         void startRedirectionTimer();
545         void stopRedirectionTimer();
546
547         void startIconLoader();
548
549 #if USE(LOW_BANDWIDTH_DISPLAY)
550         // implementation of CachedResourceClient        
551         virtual void notifyFinished(CachedResource*);
552
553         void removeAllLowBandwidthDisplayRequests();    
554         void switchOutLowBandwidthDisplayIfReady();        
555 #endif
556
557         void dispatchDidCommitLoad();
558         void dispatchAssignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&);
559         void dispatchWillSendRequest(DocumentLoader*, unsigned long identifier, ResourceRequest&, const ResourceResponse& redirectResponse);
560         void dispatchDidReceiveResponse(DocumentLoader*, unsigned long identifier, const ResourceResponse&);
561         void dispatchDidReceiveContentLength(DocumentLoader*, unsigned long identifier, int length);
562         void dispatchDidFinishLoading(DocumentLoader*, unsigned long identifier);
563         bool dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int length);
564
565         static bool isLocationChange(const ScheduledRedirection&);
566
567         Frame* m_frame;
568         FrameLoaderClient* m_client;
569
570         FrameState m_state;
571         FrameLoadType m_loadType;
572
573         RefPtr<DocumentLoader> m_documentLoader;
574         RefPtr<DocumentLoader> m_provisionalDocumentLoader;
575         RefPtr<DocumentLoader> m_policyDocumentLoader;
576
577         FrameLoadType m_policyLoadType;
578         PolicyCheck m_policyCheck;
579
580         bool m_delegateIsHandlingProvisionalLoadError;
581         bool m_delegateIsDecidingNavigationPolicy;
582         bool m_delegateIsHandlingUnimplementablePolicy;
583
584         bool m_firstLayoutDone;
585         bool m_quickRedirectComing;
586         bool m_sentRedirectNotification;
587         bool m_inStopAllLoaders;
588         bool m_navigationDuringLoad;
589
590         String m_outgoingReferrer;
591
592         CachePolicy m_cachePolicy;
593
594         HashSet<String> m_urlsBridgeKnowsAbout;
595
596         OwnPtr<FormSubmission> m_deferredFormSubmission;
597
598         bool m_isExecutingJavaScriptFormAction;
599         bool m_isRunningScript;
600
601         String m_responseMIMEType;
602
603         bool m_didCallImplicitClose;
604         bool m_wasUnloadEventEmitted;
605         bool m_isComplete;
606         bool m_isLoadingMainResource;
607
608         KURL m_URL;
609         KURL m_workingURL;
610
611         OwnPtr<IconLoader> m_iconLoader;
612         bool m_mayLoadIconLater;
613
614         bool m_cancellingWithLoadInProgress;
615
616         OwnPtr<ScheduledRedirection> m_scheduledRedirection;
617
618         bool m_needsClear;
619         bool m_receivedData;
620
621         bool m_encodingWasChosenByUser;
622         String m_encoding;
623         RefPtr<TextResourceDecoder> m_decoder;
624
625         bool m_containsPlugIns;
626
627         RefPtr<HTMLFormElement> m_formAboutToBeSubmitted;
628         HashMap<String, String> m_formValuesAboutToBeSubmitted;
629         KURL m_submittedFormURL;
630     
631         Timer<FrameLoader> m_redirectionTimer;
632         Timer<FrameLoader> m_checkCompletedTimer;
633         Timer<FrameLoader> m_checkLoadCompleteTimer;
634
635         Frame* m_opener;
636         HashSet<Frame*> m_openedFrames;
637
638         bool m_openedByDOM;
639
640         bool m_creatingInitialEmptyDocument;
641         bool m_isDisplayingInitialEmptyDocument;
642         bool m_committedFirstRealDocumentLoad;
643
644         RefPtr<HistoryItem> m_currentHistoryItem;
645         RefPtr<HistoryItem> m_previousHistoryItem;
646         RefPtr<HistoryItem> m_provisionalHistoryItem;
647         
648         bool m_didPerformFirstNavigation;
649
650 #if USE(LOW_BANDWIDTH_DISPLAY)
651         // whether to use low bandwidth dislay, set by client
652         bool m_useLowBandwidthDisplay;
653
654         // whether to call finishParsing() in switchOutLowBandwidthDisplayIfReady() 
655         bool m_finishedParsingDuringLowBandwidthDisplay;
656
657         // whether to call switchOutLowBandwidthDisplayIfReady;
658         // true if there is external css, javascript, or subframe/plugin
659         bool m_needToSwitchOutLowBandwidthDisplay;
660         
661         String m_pendingSourceInLowBandwidthDisplay;        
662         HashSet<CachedResource*> m_externalRequestsInLowBandwidthDisplay;
663 #endif   
664     };
665
666 }
667
668 #endif