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         const ResourceRequest& originalRequest() const;
 205         const ResourceRequest& initialRequest() const;
 206         void receivedMainResourceError(const ResourceError&, bool isComplete);
 207         void receivedData(const char*, int);
 208
 209         void handleFallbackContent();
 210         bool isStopping() const;
 211
 212         void finishedLoading();
 213
 214         ResourceError cancelledError(const ResourceRequest&) const;
 215         ResourceError fileDoesNotExistError(const ResourceResponse&) const;
 216         ResourceError blockedError(const ResourceRequest&) const;
 217         bool willUseArchive(ResourceLoader*, const ResourceRequest&, const KURL&) const;
 218         bool isArchiveLoadPending(ResourceLoader*) const;
 219         void cannotShowMIMEType(const ResourceResponse&);
 220         ResourceError interruptionForPolicyChangeError(const ResourceRequest&);
 221
 222         bool isHostedByObjectElement() const;
 223         bool isLoadingMainFrame() const;
 224         bool canShowMIMEType(const String& MIMEType) const;
 225         bool representationExistsForURLScheme(const String& URLScheme);
 226         String generatedMIMETypeForURLScheme(const String& URLScheme);
 227
 228         void notifyIconChanged();
 229
 230         void checkNavigationPolicy(const ResourceRequest&, NavigationPolicyDecisionFunction function, void* argument);
 231         void checkContentPolicy(const String& MIMEType, ContentPolicyDecisionFunction, void* argument);
 232         void cancelContentPolicyCheck();
 233
 234         void reload();
 235         void reloadAllowingStaleData(const String& overrideEncoding);
 236
 237         void didReceiveServerRedirectForProvisionalLoadForFrame();
 238         void finishedLoadingDocument(DocumentLoader*);
 239         void committedLoad(DocumentLoader*, const char*, int);
 240         bool isReplacing() const;
 241         void setReplacing();
 242         void revertToProvisional(DocumentLoader*);
 243         void setMainDocumentError(DocumentLoader*, const ResourceError&);
 244         void mainReceivedCompleteError(DocumentLoader*, const ResourceError&);
 245         bool subframeIsLoading() const;
 246         void willChangeTitle(DocumentLoader*);
 247         void didChangeTitle(DocumentLoader*);
 248
 249         FrameLoadType loadType() const;
 250
 251         void didFirstLayout();
 252         bool firstLayoutDone() const;
 253
 254         void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
 255         void clientRedirected(const KURL&, double delay, double fireDate, bool lockHistory, bool isJavaScriptFormAction);
 256         bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
 257
 258         bool isQuickRedirectComing() const;
 259
 260         void sendRemainingDelegateMessages(unsigned long identifier, const ResourceResponse&, int length, const ResourceError&);
 261         void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
 262         void loadedResourceFromMemoryCache(const ResourceRequest&, const ResourceResponse&, int length);
 263
 264         void recursiveCheckLoadComplete();
 265         void checkLoadComplete();
 266         void detachFromParent();
 267         void detachChildren();
 268
 269         void addExtraFieldsToRequest(ResourceRequest&, bool isMainResource, bool alwaysFromRequest);
 270
 271         FrameLoaderClient* client() const;
 272
 273         void setDefersLoading(bool);
 274
 275         void changeLocation(const String& URL, const String& referrer, bool lockHistory = true, bool userGesture = false);
 276         void changeLocation(const KURL& URL, const String& referrer, bool lockHistory = true, bool userGesture = false);
 277         void urlSelected(const ResourceRequest&, const String& target, Event*, bool lockHistory, bool userGesture);
 278         void urlSelected(const FrameLoadRequest&, Event*, bool lockHistory, bool userGesture);
 279
 280         bool requestFrame(HTMLFrameOwnerElement*, const String& URL, const AtomicString& frameName);
 281         Frame* loadSubframe(HTMLFrameOwnerElement*, const KURL& URL, const String& name, const String& referrer);
 282
 283         void submitForm(const char* action, const String& URL, PassRefPtr<FormData>, const String& target, const String& contentType, const String& boundary, Event*);
 284         void submitFormAgain();
 285         void submitForm(const FrameLoadRequest&, Event*);
 286
 287         void stop();
 288         void stopLoading(bool sendUnload);
 289         bool closeURL();
 290
 291         void didExplicitOpen();
 292
 293         KURL iconURL();
 294         void commitIconURLToIconDatabase(const KURL&);
 295
 296         KURL baseURL() const;
 297         String baseTarget() const;
 298         KURL dataURLBaseFromRequest(const ResourceRequest& request) const;
 299
 300         bool isScheduledLocationChangePending() const { return m_scheduledRedirection && isLocationChange(*m_scheduledRedirection); }
 301         void scheduleHTTPRedirection(double delay, const String& URL);
 302         void scheduleLocationChange(const String& URL, const String& referrer, bool lockHistory = true, bool userGesture = false);
 303         void scheduleRefresh(bool userGesture = false);
 304         void scheduleHistoryNavigation(int steps);
 305
 306         bool canGoBackOrForward(int distance) const;
 307         void goBackOrForward(int distance);
 308         int getHistoryLength();
 309         KURL historyURL(int distance);
 310
 311         void begin();
 312         void begin(const KURL&, bool dispatchWindowObjectAvailable = true);
 313
 314         void write(const char* str, int len = -1, bool flush = false);
 315         void write(const String&);
 316         void end();
 317         void endIfNotLoadingMainResource();
 318
 319         void setEncoding(const String& encoding, bool userChosen);
 320         String encoding() const;
 321
 322         KJS::JSValue* executeScript(const String& URL, int baseLine, const String& script);
 323         KJS::JSValue* executeScript(const String& script, bool forceUserGesture = false);
 324
 325         void gotoAnchor();
 326         bool gotoAnchor(const String& name); // returns true if the anchor was found
 327         void scrollToAnchor(const KURL&);
 328
 329         void tokenizerProcessedData();
 330
 331         void handledOnloadEvents();
 332         String userAgent(const KURL&) const;
 333
 334         Widget* createJavaAppletWidget(const IntSize&, Element*, const HashMap<String, String>& args);
 335
 336         void dispatchWindowObjectAvailable();
 337         void restoreDocumentState();
 338
 339         Frame* opener();
 340         void setOpener(Frame*);
 341         bool openedByDOM() const;
 342         void setOpenedByDOM();
 343
 344         void provisionalLoadStarted();
 345
 346         bool userGestureHint();
 347
 348         void resetMultipleFormSubmissionProtection();
 349         void didNotOpenURL(const KURL&);
 350
 351         void addData(const char* bytes, int length);
 352
 353         bool canCachePage();
 354
 355         void checkCallImplicitClose();
 356         bool didOpenURL(const KURL&);
 357
 358         void frameDetached();
 359
 360         // FIXME: Which one of these URL methods is right?
 361         KURL url() const;
 362         KURL URL() const;
 363
 364         void updateBaseURLForEmptyDocument();
 365
 366         void setResponseMIMEType(const String&);
 367         const String& responseMIMEType() const;
 368
 369         bool containsPlugins() const;
 370
 371         void loadDone();
 372         void finishedParsing();
 373         void checkCompleted();
 374         void scheduleCheckCompleted();
 375         void scheduleCheckLoadComplete();
 376
 377         void clearRecordedFormValues();
 378         void recordFormValue(const String& name, const String& value, PassRefPtr<HTMLFormElement>);
 379
 380         bool isComplete() const;
 381
 382         bool requestObject(RenderPart* frame, const String& URL, const AtomicString& frameName,
 383             const String& serviceType, const Vector<String>& paramNames, const Vector<String>& paramValues);
 384
 385         KURL completeURL(const String& URL);
 386
 387         void didTellBridgeAboutLoad(const String& URL);
 388         bool haveToldBridgeAboutLoad(const String& URL);
 389
 390         KURL originalRequestURL() const;
 391
 392         void cancelAndClear();
 393
 394         void setTitle(const String&);
 395
 396         bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
 397
 398         void commitProvisionalLoad(PassRefPtr<CachedPage>);
 399
 400         void goToItem(HistoryItem*, FrameLoadType);
 401         void saveDocumentAndScrollState();
 402         void saveScrollPositionAndViewStateToItem(HistoryItem*);
 403
 404         // FIXME: These accessors are here for a dwindling number of users in WebKit, WebFrame
 405         // being the primary one.  After they're no longer needed there, they can be removed!
 406         HistoryItem* currentHistoryItem();
 407         HistoryItem* previousHistoryItem();
 408         HistoryItem* provisionalHistoryItem();
 409         void setCurrentHistoryItem(PassRefPtr<HistoryItem>);
 410         void setPreviousHistoryItem(PassRefPtr<HistoryItem>);
 411         void setProvisionalHistoryItem(PassRefPtr<HistoryItem>);
 412
 413         void continueLoadWithData(SharedBuffer*, const String& mimeType, const String& textEncoding, const KURL&);
 414
 415         static void registerURLSchemeAsLocal(const String& scheme);
 416         static bool restrictAccessToLocal();
 417         static void setRestrictAccessToLocal(bool);
 418         static bool shouldTreatURLAsLocal(const String&);
 419         static bool shouldTreatSchemeAsLocal(const String&);
 420
 421 #if USE(LOW_BANDWIDTH_DISPLAY)
 422         bool addLowBandwidthDisplayRequest(CachedResource*);
 423         void needToSwitchOutLowBandwidthDisplay() { m_needToSwitchOutLowBandwidthDisplay = true; }
 424
 425         // Client can control whether to use low bandwidth display on a per frame basis.
 426         // However, this should only be used for the top frame, not sub-frame.
 427         void setUseLowBandwidthDisplay(bool lowBandwidth) { m_useLowBandwidthDisplay = lowBandwidth; }
 428         bool useLowBandwidthDisplay() const { return m_useLowBandwidthDisplay; }
 429 #endif
 430
 431         bool committingFirstRealLoad() const { return !m_creatingInitialEmptyDocument && !m_committedFirstRealDocumentLoad; }
 432
 433         void iconLoadDecisionAvailable();
 434
 435         bool shouldAllowNavigation(Frame* targetFrame) const;
 436
 437     private:
 438         PassRefPtr<HistoryItem> createHistoryItem(bool useOriginal);
 439         PassRefPtr<HistoryItem> createHistoryItemTree(Frame* targetFrame, bool clipAtTarget);
 440
 441         void addBackForwardItemClippedAtTarget(bool doClip);
 442         void restoreScrollPositionAndViewState();
 443         void saveDocumentState();
 444         void loadItem(HistoryItem*, FrameLoadType);
 445         bool urlsMatchItem(HistoryItem*) const;
 446         void invalidateCurrentItemCachedPage();
 447         void recursiveGoToItem(HistoryItem*, HistoryItem*, FrameLoadType);
 448         bool childFramesMatchItem(HistoryItem*) const;
 449
 450         void addHistoryForCurrentLocation();
 451         void updateHistoryForBackForwardNavigation();
 452         void updateHistoryForReload();
 453         void updateHistoryForStandardLoad();
 454         void updateHistoryForRedirectWithLockedHistory();
 455         void updateHistoryForClientRedirect();
 456         void updateHistoryForCommit();
 457
 458         void redirectionTimerFired(Timer<FrameLoader>*);
 459         void checkCompletedTimerFired(Timer<FrameLoader>*);
 460         void checkLoadCompleteTimerFired(Timer<FrameLoader>*);
 461
 462         void cancelRedirection(bool newLoadInProgress = false);
 463
 464         void started();
 465
 466         void completed();
 467         void parentCompleted();
 468
 469         bool shouldUsePlugin(const KURL&, const String& mimeType, bool hasFallback, bool& useFallback);
 470         bool loadPlugin(RenderPart*, const KURL&, const String& mimeType,
 471         const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback);
 472
 473         bool loadProvisionalItemFromCachedPage();
 474         void cachePageForHistoryItem(HistoryItem*);
 475
 476         void receivedFirstData();
 477
 478         void updatePolicyBaseURL();
 479         void setPolicyBaseURL(const String&);
 480
 481         void replaceContentsWithScriptResult(const KURL&);
 482
 483         // Also not cool.
 484         void stopLoadingSubframes();
 485
 486         void clearProvisionalLoad();
 487         void markLoadComplete();
 488         void transitionToCommitted(PassRefPtr<CachedPage>);
 489         void frameLoadCompleted();
 490
 491         void mainReceivedError(const ResourceError&, bool isComplete);
 492
 493         void setLoadType(FrameLoadType);
 494
 495         void checkNavigationPolicy(const ResourceRequest&, DocumentLoader*, PassRefPtr<FormState>,
 496                                    NavigationPolicyDecisionFunction, void* argument);
 497         void checkNewWindowPolicy(const NavigationAction&, const ResourceRequest&,
 498                                   PassRefPtr<FormState>, const String& frameName);
 499
 500         void continueAfterNavigationPolicy(PolicyAction);
 501         void continueAfterNewWindowPolicy(PolicyAction);
 502         void continueAfterContentPolicy(PolicyAction);
 503         void continueLoadAfterWillSubmitForm(PolicyAction = PolicyUse);
 504
 505         static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
 506         void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
 507         static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
 508         void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
 509         static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
 510         void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
 511         void addHistoryItemForFragmentScroll();
 512
 513         void stopPolicyCheck();
 514
 515         void closeDocument();
 516
 517         void checkLoadCompleteForThisFrame();
 518
 519         void setDocumentLoader(DocumentLoader*);
 520         void setPolicyDocumentLoader(DocumentLoader*);
 521         void setProvisionalDocumentLoader(DocumentLoader*);
 522
 523         void setState(FrameState);
 524
 525         void closeOldDataSources();
 526         void open(CachedPage&);
 527         void opened();
 528         void updateHistoryAfterClientRedirect();
 529
 530         void clear(bool clearWindowProperties = true, bool clearScriptObjects = true);
 531
 532         bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
 533         void handleUnimplementablePolicy(const ResourceError&);
 534
 535         void applyUserAgent(ResourceRequest& request);
 536
 537         void scheduleRedirection(ScheduledRedirection*);
 538         void startRedirectionTimer();
 539         void stopRedirectionTimer();
 540
 541         void startIconLoader();
 542
 543 #if USE(LOW_BANDWIDTH_DISPLAY)
 544         // implementation of CachedResourceClient
 545         virtual void notifyFinished(CachedResource*);
 546
 547         void removeAllLowBandwidthDisplayRequests();
 548         void switchOutLowBandwidthDisplayIfReady();
 549 #endif
 550
 551         void dispatchDidCommitLoad();
 552         void dispatchAssignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&);
 553         void dispatchWillSendRequest(DocumentLoader*, unsigned long identifier, ResourceRequest&, const ResourceResponse& redirectResponse);
 554         void dispatchDidReceiveResponse(DocumentLoader*, unsigned long identifier, const ResourceResponse&);
 555         void dispatchDidReceiveContentLength(DocumentLoader*, unsigned long identifier, int length);
 556         void dispatchDidFinishLoading(DocumentLoader*, unsigned long identifier);
 557         bool dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int length);
 558
 559         static bool isLocationChange(const ScheduledRedirection&);
 560
 561         Frame* m_frame;
 562         FrameLoaderClient* m_client;
 563
 564         FrameState m_state;
 565         FrameLoadType m_loadType;
 566
 567         RefPtr<DocumentLoader> m_documentLoader;
 568         RefPtr<DocumentLoader> m_provisionalDocumentLoader;
 569         RefPtr<DocumentLoader> m_policyDocumentLoader;
 570
 571         FrameLoadType m_policyLoadType;
 572         PolicyCheck m_policyCheck;
 573
 574         bool m_delegateIsHandlingProvisionalLoadError;
 575         bool m_delegateIsDecidingNavigationPolicy;
 576         bool m_delegateIsHandlingUnimplementablePolicy;
 577
 578         bool m_firstLayoutDone;
 579         bool m_quickRedirectComing;
 580         bool m_sentRedirectNotification;
 581         bool m_inStopAllLoaders;
 582         bool m_navigationDuringLoad;
 583
 584         String m_outgoingReferrer;
 585
 586         CachePolicy m_cachePolicy;
 587
 588         HashSet<String> m_urlsBridgeKnowsAbout;
 589
 590         OwnPtr<FormSubmission> m_deferredFormSubmission;
 591
 592         bool m_isExecutingJavaScriptFormAction;
 593         bool m_isRunningScript;
 594
 595         String m_responseMIMEType;
 596
 597         bool m_didCallImplicitClose;
 598         bool m_wasUnloadEventEmitted;
 599         bool m_isComplete;
 600         bool m_isLoadingMainResource;
 601
 602         KURL m_URL;
 603         KURL m_workingURL;
 604
 605         OwnPtr<IconLoader> m_iconLoader;
 606         bool m_mayLoadIconLater;
 607
 608         bool m_cancellingWithLoadInProgress;
 609
 610         OwnPtr<ScheduledRedirection> m_scheduledRedirection;
 611
 612         bool m_needsClear;
 613         bool m_receivedData;
 614
 615         bool m_encodingWasChosenByUser;
 616         String m_encoding;
 617         RefPtr<TextResourceDecoder> m_decoder;
 618
 619         bool m_containsPlugIns;
 620
 621         RefPtr<HTMLFormElement> m_formAboutToBeSubmitted;
 622         HashMap<String, String> m_formValuesAboutToBeSubmitted;
 623         KURL m_submittedFormURL;
 624
 625         Timer<FrameLoader> m_redirectionTimer;
 626         Timer<FrameLoader> m_checkCompletedTimer;
 627         Timer<FrameLoader> m_checkLoadCompleteTimer;
 628
 629         Frame* m_opener;
 630         HashSet<Frame*> m_openedFrames;
 631
 632         bool m_openedByDOM;
 633
 634         bool m_creatingInitialEmptyDocument;
 635         bool m_isDisplayingInitialEmptyDocument;
 636         bool m_committedFirstRealDocumentLoad;
 637
 638         RefPtr<HistoryItem> m_currentHistoryItem;
 639         RefPtr<HistoryItem> m_previousHistoryItem;
 640         RefPtr<HistoryItem> m_provisionalHistoryItem;
 641
 642         bool m_didPerformFirstNavigation;
 643
 644 #ifndef NDEBUG
 645         bool m_didDispatchDidCommitLoad;
 646 #endif
 647
 648 #if USE(LOW_BANDWIDTH_DISPLAY)
 649         // whether to use low bandwidth dislay, set by client
 650         bool m_useLowBandwidthDisplay;
 651
 652         // whether to call finishParsing() in switchOutLowBandwidthDisplayIfReady()
 653         bool m_finishedParsingDuringLowBandwidthDisplay;
 654
 655         // whether to call switchOutLowBandwidthDisplayIfReady;
 656         // true if there is external css, javascript, or subframe/plugin
 657         bool m_needToSwitchOutLowBandwidthDisplay;
 658
 659         String m_pendingSourceInLowBandwidthDisplay;
 660         HashSet<CachedResource*> m_externalRequestsInLowBandwidthDisplay;
 661 #endif
 662     };
 663
 664 }
 665
 666 #endif