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